Merge remote-tracking branch 'origin/released'

9 files changed, 932 insertions, 910 deletions

diff --git a/mesalib/src/mesa/main/attrib.c b/mesalib/src/mesa/main/attrib.c
index 573100402..9767740a3 100644
--- a/mesalib/src/mesa/main/attrib.c
+++ b/mesalib/src/mesa/main/attrib.c
@@ -884,10 +884,10 @@ _mesa_PopAttrib(void)
 
                color = (const struct gl_colorbuffer_attrib *) attr->data;
                _mesa_ClearIndex((GLfloat) color->ClearIndex);
-               _mesa_ClearColor(color->ClearColorUnclamped[0],
-                                color->ClearColorUnclamped[1],
-                                color->ClearColorUnclamped[2],
-                                color->ClearColorUnclamped[3]);
+               _mesa_ClearColor(color->ClearColor.f[0],
+                                color->ClearColor.f[1],
+                                color->ClearColor.f[2],
+                                color->ClearColor.f[3]);
                _mesa_IndexMask(color->IndexMask);
                if (!ctx->Extensions.EXT_draw_buffers2) {
                   _mesa_ColorMask((GLboolean) (color->ColorMask[0][0] != 0),
diff --git a/mesalib/src/mesa/main/blend.c b/mesalib/src/mesa/main/blend.c
index 94a457f58..4214a661b 100644
--- a/mesalib/src/mesa/main/blend.c
+++ b/mesalib/src/mesa/main/blend.c
@@ -1,833 +1,832 @@
-/**

- * \file blend.c

- * Blending operations.

- */

-

-/*

- * Mesa 3-D graphics library

- * Version:  6.5.1

- *

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

- *

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

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

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

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

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

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

- *

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

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

- *

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

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

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

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

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

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

- */

-

-

-

-#include "glheader.h"

-#include "blend.h"

-#include "context.h"

-#include "enums.h"

-#include "macros.h"

-#include "mtypes.h"

-

-

-

-/**

- * Check if given blend source factor is legal.

- * \return GL_TRUE if legal, GL_FALSE otherwise.

- */

-static GLboolean

-legal_src_factor(const struct gl_context *ctx, GLenum factor)

-{

-   switch (factor) {

-   case GL_SRC_COLOR:

-   case GL_ONE_MINUS_SRC_COLOR:

-      return ctx->Extensions.NV_blend_square;

-   case GL_ZERO:

-   case GL_ONE:

-   case GL_DST_COLOR:

-   case GL_ONE_MINUS_DST_COLOR:

-   case GL_SRC_ALPHA:

-   case GL_ONE_MINUS_SRC_ALPHA:

-   case GL_DST_ALPHA:

-   case GL_ONE_MINUS_DST_ALPHA:

-   case GL_SRC_ALPHA_SATURATE:

-   case GL_CONSTANT_COLOR:

-   case GL_ONE_MINUS_CONSTANT_COLOR:

-   case GL_CONSTANT_ALPHA:

-   case GL_ONE_MINUS_CONSTANT_ALPHA:

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-/**

- * Check if given blend destination factor is legal.

- * \return GL_TRUE if legal, GL_FALSE otherwise.

- */

-static GLboolean

-legal_dst_factor(const struct gl_context *ctx, GLenum factor)

-{

-   switch (factor) {

-   case GL_DST_COLOR:

-   case GL_ONE_MINUS_DST_COLOR:

-      return ctx->Extensions.NV_blend_square;

-   case GL_ZERO:

-   case GL_ONE:

-   case GL_SRC_COLOR:

-   case GL_ONE_MINUS_SRC_COLOR:

-   case GL_SRC_ALPHA:

-   case GL_ONE_MINUS_SRC_ALPHA:

-   case GL_DST_ALPHA:

-   case GL_ONE_MINUS_DST_ALPHA:

-   case GL_CONSTANT_COLOR:

-   case GL_ONE_MINUS_CONSTANT_COLOR:

-   case GL_CONSTANT_ALPHA:

-   case GL_ONE_MINUS_CONSTANT_ALPHA:

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-/**

- * Check if src/dest RGB/A blend factors are legal.  If not generate

- * a GL error.

- * \return GL_TRUE if factors are legal, GL_FALSE otherwise.

- */

-static GLboolean

-validate_blend_factors(struct gl_context *ctx, const char *func,

-                       GLenum sfactorRGB, GLenum dfactorRGB,

-                       GLenum sfactorA, GLenum dfactorA)

-{

-   if (!legal_src_factor(ctx, sfactorRGB)) {

-      _mesa_error(ctx, GL_INVALID_ENUM,

-                  "%s(sfactorRGB = %s)", func,

-                  _mesa_lookup_enum_by_nr(sfactorRGB));

-      return GL_FALSE;

-   }

-

-   if (!legal_dst_factor(ctx, dfactorRGB)) {

-      _mesa_error(ctx, GL_INVALID_ENUM,

-                  "%s(dfactorRGB = %s)", func,

-                  _mesa_lookup_enum_by_nr(dfactorRGB));

-      return GL_FALSE;

-   }

-

-   if (sfactorA != sfactorRGB && !legal_src_factor(ctx, sfactorA)) {

-      _mesa_error(ctx, GL_INVALID_ENUM,

-                  "%s(sfactorA = %s)", func,

-                  _mesa_lookup_enum_by_nr(sfactorA));

-      return GL_FALSE;

-   }

-

-   if (dfactorA != dfactorRGB && !legal_dst_factor(ctx, dfactorA)) {

-      _mesa_error(ctx, GL_INVALID_ENUM,

-                  "%s(dfactorA = %s)", func,

-                  _mesa_lookup_enum_by_nr(dfactorA));

-      return GL_FALSE;

-   }

-

-   return GL_TRUE;

-}

-

-

-/**

- * Specify the blending operation.

- *

- * \param sfactor source factor operator.

- * \param dfactor destination factor operator.

- *

- * \sa glBlendFunc, glBlendFuncSeparateEXT

- */

-void GLAPIENTRY

-_mesa_BlendFunc( GLenum sfactor, GLenum dfactor )

-{

-   _mesa_BlendFuncSeparateEXT(sfactor, dfactor, sfactor, dfactor);

-}

-

-

-/**

- * Set the separate blend source/dest factors for all draw buffers.

- *

- * \param sfactorRGB RGB source factor operator.

- * \param dfactorRGB RGB destination factor operator.

- * \param sfactorA alpha source factor operator.

- * \param dfactorA alpha destination factor operator.

- */

-void GLAPIENTRY

-_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,

-                            GLenum sfactorA, GLenum dfactorA )

-{

-   GLuint buf, numBuffers;

-   GLboolean changed;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glBlendFuncSeparate %s %s %s %s\n",

-                  _mesa_lookup_enum_by_nr(sfactorRGB),

-                  _mesa_lookup_enum_by_nr(dfactorRGB),

-                  _mesa_lookup_enum_by_nr(sfactorA),

-                  _mesa_lookup_enum_by_nr(dfactorA));

-

-   if (!validate_blend_factors(ctx, "glBlendFuncSeparate",

-                               sfactorRGB, dfactorRGB,

-                               sfactorA, dfactorA)) {

-      return;

-   }

-

-   numBuffers = ctx->Extensions.ARB_draw_buffers_blend

-      ? ctx->Const.MaxDrawBuffers : 1;

-

-   changed = GL_FALSE;

-   for (buf = 0; buf < numBuffers; buf++) {

-      if (ctx->Color.Blend[buf].SrcRGB != sfactorRGB ||

-          ctx->Color.Blend[buf].DstRGB != dfactorRGB ||

-          ctx->Color.Blend[buf].SrcA != sfactorA ||

-          ctx->Color.Blend[buf].DstA != dfactorA) {

-         changed = GL_TRUE;

-         break;

-      }

-   }

-   if (!changed)

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-

-   for (buf = 0; buf < numBuffers; buf++) {

-      ctx->Color.Blend[buf].SrcRGB = sfactorRGB;

-      ctx->Color.Blend[buf].DstRGB = dfactorRGB;

-      ctx->Color.Blend[buf].SrcA = sfactorA;

-      ctx->Color.Blend[buf].DstA = dfactorA;

-   }

-   ctx->Color._BlendFuncPerBuffer = GL_FALSE;

-

-   if (ctx->Driver.BlendFuncSeparate) {

-      ctx->Driver.BlendFuncSeparate(ctx, sfactorRGB, dfactorRGB,

-                                    sfactorA, dfactorA);

-   }

-}

-

-

-#if _HAVE_FULL_GL

-

-

-/**

- * Set blend source/dest factors for one color buffer/target.

- */

-void GLAPIENTRY

-_mesa_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)

-{

-   _mesa_BlendFuncSeparatei(buf, sfactor, dfactor, sfactor, dfactor);

-}

-

-

-/**

- * Set separate blend source/dest factors for one color buffer/target.

- */

-void GLAPIENTRY

-_mesa_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,

-                         GLenum sfactorA, GLenum dfactorA)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (!ctx->Extensions.ARB_draw_buffers_blend) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendFunc[Separate]i()");

-      return;

-   }

-

-   if (buf >= ctx->Const.MaxDrawBuffers) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",

-                  buf);

-      return;

-   }

-

-   if (!validate_blend_factors(ctx, "glBlendFuncSeparatei",

-                               sfactorRGB, dfactorRGB,

-                               sfactorA, dfactorA)) {

-      return;

-   }

-

-   if (ctx->Color.Blend[buf].SrcRGB == sfactorRGB &&

-       ctx->Color.Blend[buf].DstRGB == dfactorRGB &&

-       ctx->Color.Blend[buf].SrcA == sfactorA &&

-       ctx->Color.Blend[buf].DstA == dfactorA)

-      return; /* no change */

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-

-   ctx->Color.Blend[buf].SrcRGB = sfactorRGB;

-   ctx->Color.Blend[buf].DstRGB = dfactorRGB;

-   ctx->Color.Blend[buf].SrcA = sfactorA;

-   ctx->Color.Blend[buf].DstA = dfactorA;

-   ctx->Color._BlendFuncPerBuffer = GL_TRUE;

-

-   if (ctx->Driver.BlendFuncSeparatei) {

-      ctx->Driver.BlendFuncSeparatei(ctx, buf, sfactorRGB, dfactorRGB,

-                                     sfactorA, dfactorA);

-   }

-}

-

-

-/**

- * Check if given blend equation is legal.

- * \return GL_TRUE if legal, GL_FALSE otherwise.

- */

-static GLboolean

-legal_blend_equation(const struct gl_context *ctx,

-                     GLenum mode, GLboolean is_separate)

-{

-   switch (mode) {

-   case GL_FUNC_ADD:

-      return GL_TRUE;

-   case GL_MIN:

-   case GL_MAX:

-      return ctx->Extensions.EXT_blend_minmax;

-   case GL_LOGIC_OP:

-      /* glBlendEquationSeparate cannot take GL_LOGIC_OP as a parameter.

-       */

-      return ctx->Extensions.EXT_blend_logic_op && !is_separate;

-   case GL_FUNC_SUBTRACT:

-   case GL_FUNC_REVERSE_SUBTRACT:

-      return ctx->Extensions.EXT_blend_subtract;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-/* This is really an extension function! */

-void GLAPIENTRY

-_mesa_BlendEquation( GLenum mode )

-{

-   GLuint buf, numBuffers;

-   GLboolean changed;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glBlendEquation(%s)\n",

-                  _mesa_lookup_enum_by_nr(mode));

-

-   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");

-      return;

-   }

-

-   numBuffers = ctx->Extensions.ARB_draw_buffers_blend

-      ? ctx->Const.MaxDrawBuffers : 1;

-

-   changed = GL_FALSE;

-   for (buf = 0; buf < numBuffers; buf++) {

-      if (ctx->Color.Blend[buf].EquationRGB != mode ||

-          ctx->Color.Blend[buf].EquationA != mode) {

-         changed = GL_TRUE;

-         break;

-      }

-   }

-   if (!changed)

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   for (buf = 0; buf < numBuffers; buf++) {

-      ctx->Color.Blend[buf].EquationRGB = mode;

-      ctx->Color.Blend[buf].EquationA = mode;

-   }

-   ctx->Color._BlendEquationPerBuffer = GL_FALSE;

-

-   if (ctx->Driver.BlendEquationSeparate)

-      (*ctx->Driver.BlendEquationSeparate)( ctx, mode, mode );

-}

-

-

-/**

- * Set blend equation for one color buffer/target.

- */

-void GLAPIENTRY

-_mesa_BlendEquationi(GLuint buf, GLenum mode)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glBlendEquationi(%u, %s)\n",

-                  buf, _mesa_lookup_enum_by_nr(mode));

-

-   if (buf >= ctx->Const.MaxDrawBuffers) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",

-                  buf);

-      return;

-   }

-

-   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationi");

-      return;

-   }

-

-   if (ctx->Color.Blend[buf].EquationRGB == mode &&

-       ctx->Color.Blend[buf].EquationA == mode)

-      return;  /* no change */

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   ctx->Color.Blend[buf].EquationRGB = mode;

-   ctx->Color.Blend[buf].EquationA = mode;

-   ctx->Color._BlendEquationPerBuffer = GL_TRUE;

-

-   if (ctx->Driver.BlendEquationSeparatei)

-      ctx->Driver.BlendEquationSeparatei(ctx, buf, mode, mode);

-}

-

-

-void GLAPIENTRY

-_mesa_BlendEquationSeparateEXT( GLenum modeRGB, GLenum modeA )

-{

-   GLuint buf, numBuffers;

-   GLboolean changed;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glBlendEquationSeparateEXT(%s %s)\n",

-                  _mesa_lookup_enum_by_nr(modeRGB),

-                  _mesa_lookup_enum_by_nr(modeA));

-

-   if ( (modeRGB != modeA) && !ctx->Extensions.EXT_blend_equation_separate ) {

-      _mesa_error(ctx, GL_INVALID_OPERATION,

-		  "glBlendEquationSeparateEXT not supported by driver");

-      return;

-   }

-

-   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeRGB)");

-      return;

-   }

-

-   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeA)");

-      return;

-   }

-

-   numBuffers = ctx->Extensions.ARB_draw_buffers_blend

-      ? ctx->Const.MaxDrawBuffers : 1;

-

-   changed = GL_FALSE;

-   for (buf = 0; buf < numBuffers; buf++) {

-      if (ctx->Color.Blend[buf].EquationRGB != modeRGB ||

-          ctx->Color.Blend[buf].EquationA != modeA) {

-         changed = GL_TRUE;

-         break;

-      }

-   }

-   if (!changed)

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   for (buf = 0; buf < numBuffers; buf++) {

-      ctx->Color.Blend[buf].EquationRGB = modeRGB;

-      ctx->Color.Blend[buf].EquationA = modeA;

-   }

-   ctx->Color._BlendEquationPerBuffer = GL_FALSE;

-

-   if (ctx->Driver.BlendEquationSeparate)

-      ctx->Driver.BlendEquationSeparate(ctx, modeRGB, modeA);

-}

-

-

-/**

- * Set separate blend equations for one color buffer/target.

- */

-void GLAPIENTRY

-_mesa_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glBlendEquationSeparatei(%u, %s %s)\n", buf,

-                  _mesa_lookup_enum_by_nr(modeRGB),

-                  _mesa_lookup_enum_by_nr(modeA));

-

-   if (buf >= ctx->Const.MaxDrawBuffers) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendEquationSeparatei(buffer=%u)",

-                  buf);

-      return;

-   }

-

-   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeRGB)");

-      return;

-   }

-

-   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeA)");

-      return;

-   }

-

-   if (ctx->Color.Blend[buf].EquationRGB == modeRGB &&

-       ctx->Color.Blend[buf].EquationA == modeA)

-      return;  /* no change */

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   ctx->Color.Blend[buf].EquationRGB = modeRGB;

-   ctx->Color.Blend[buf].EquationA = modeA;

-   ctx->Color._BlendEquationPerBuffer = GL_TRUE;

-

-   if (ctx->Driver.BlendEquationSeparatei)

-      ctx->Driver.BlendEquationSeparatei(ctx, buf, modeRGB, modeA);

-}

-

-

-

-#endif /* _HAVE_FULL_GL */

-

-

-/**

- * Set the blending color.

- *

- * \param red red color component.

- * \param green green color component.

- * \param blue blue color component.

- * \param alpha alpha color component.

- *

- * \sa glBlendColor().

- *

- * Clamps the parameters and updates gl_colorbuffer_attrib::BlendColor.  On a

- * change, flushes the vertices and notifies the driver via

- * dd_function_table::BlendColor callback.

- */

-void GLAPIENTRY

-_mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )

-{

-   GLfloat tmp[4];

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   tmp[0] = red;

-   tmp[1] = green;

-   tmp[2] = blue;

-   tmp[3] = alpha;

-

-   if (TEST_EQ_4V(tmp, ctx->Color.BlendColorUnclamped))

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   COPY_4FV( ctx->Color.BlendColorUnclamped, tmp );

-

-   ctx->Color.BlendColor[0] = CLAMP(tmp[0], 0.0F, 1.0F);

-   ctx->Color.BlendColor[1] = CLAMP(tmp[1], 0.0F, 1.0F);

-   ctx->Color.BlendColor[2] = CLAMP(tmp[2], 0.0F, 1.0F);

-   ctx->Color.BlendColor[3] = CLAMP(tmp[3], 0.0F, 1.0F);

-

-   if (ctx->Driver.BlendColor)

-      (*ctx->Driver.BlendColor)(ctx, ctx->Color.BlendColor);

-}

-

-

-/**

- * Specify the alpha test function.

- *

- * \param func alpha comparison function.

- * \param ref reference value.

- *

- * Verifies the parameters and updates gl_colorbuffer_attrib. 

- * On a change, flushes the vertices and notifies the driver via

- * dd_function_table::AlphaFunc callback.

- */

-void GLAPIENTRY

-_mesa_AlphaFunc( GLenum func, GLclampf ref )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glAlphaFunc(%s, %f)\n",

-                  _mesa_lookup_enum_by_nr(func), ref);

-

-   switch (func) {

-   case GL_NEVER:

-   case GL_LESS:

-   case GL_EQUAL:

-   case GL_LEQUAL:

-   case GL_GREATER:

-   case GL_NOTEQUAL:

-   case GL_GEQUAL:

-   case GL_ALWAYS:

-      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRefUnclamped == ref)

-         return; /* no change */

-

-      FLUSH_VERTICES(ctx, _NEW_COLOR);

-      ctx->Color.AlphaFunc = func;

-      ctx->Color.AlphaRefUnclamped = ref;

-      ctx->Color.AlphaRef = CLAMP(ref, 0.0F, 1.0F);

-

-      if (ctx->Driver.AlphaFunc)

-         ctx->Driver.AlphaFunc(ctx, func, ctx->Color.AlphaRef);

-      return;

-

-   default:

-      _mesa_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );

-      return;

-   }

-}

-

-

-/**

- * Specify a logic pixel operation for color index rendering.

- *

- * \param opcode operation.

- *

- * Verifies that \p opcode is a valid enum and updates

-gl_colorbuffer_attrib::LogicOp.

- * On a change, flushes the vertices and notifies the driver via the

- * dd_function_table::LogicOpcode callback.

- */

-void GLAPIENTRY

-_mesa_LogicOp( GLenum opcode )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glLogicOp(%s)\n", _mesa_lookup_enum_by_nr(opcode));

-

-   switch (opcode) {

-      case GL_CLEAR:

-      case GL_SET:

-      case GL_COPY:

-      case GL_COPY_INVERTED:

-      case GL_NOOP:

-      case GL_INVERT:

-      case GL_AND:

-      case GL_NAND:

-      case GL_OR:

-      case GL_NOR:

-      case GL_XOR:

-      case GL_EQUIV:

-      case GL_AND_REVERSE:

-      case GL_AND_INVERTED:

-      case GL_OR_REVERSE:

-      case GL_OR_INVERTED:

-	 break;

-      default:

-         _mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );

-	 return;

-   }

-

-   if (ctx->Color.LogicOp == opcode)

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   ctx->Color.LogicOp = opcode;

-

-   if (ctx->Driver.LogicOpcode)

-      ctx->Driver.LogicOpcode( ctx, opcode );

-}

-

-#if _HAVE_FULL_GL

-void GLAPIENTRY

-_mesa_IndexMask( GLuint mask )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (ctx->Color.IndexMask == mask)

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   ctx->Color.IndexMask = mask;

-}

-#endif

-

-

-/**

- * Enable or disable writing of frame buffer color components.

- *

- * \param red whether to mask writing of the red color component.

- * \param green whether to mask writing of the green color component.

- * \param blue whether to mask writing of the blue color component.

- * \param alpha whether to mask writing of the alpha color component.

- *

- * \sa glColorMask().

- *

- * Sets the appropriate value of gl_colorbuffer_attrib::ColorMask.  On a

- * change, flushes the vertices and notifies the driver via the

- * dd_function_table::ColorMask callback.

- */

-void GLAPIENTRY

-_mesa_ColorMask( GLboolean red, GLboolean green,

-                 GLboolean blue, GLboolean alpha )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLubyte tmp[4];

-   GLuint i;

-   GLboolean flushed;

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glColorMask(%d, %d, %d, %d)\n",

-                  red, green, blue, alpha);

-

-   /* Shouldn't have any information about channel depth in core mesa

-    * -- should probably store these as the native booleans:

-    */

-   tmp[RCOMP] = red    ? 0xff : 0x0;

-   tmp[GCOMP] = green  ? 0xff : 0x0;

-   tmp[BCOMP] = blue   ? 0xff : 0x0;

-   tmp[ACOMP] = alpha  ? 0xff : 0x0;

-

-   flushed = GL_FALSE;

-   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

-      if (!TEST_EQ_4V(tmp, ctx->Color.ColorMask[i])) {

-         if (!flushed) {

-            FLUSH_VERTICES(ctx, _NEW_COLOR);

-         }

-         flushed = GL_TRUE;

-         COPY_4UBV(ctx->Color.ColorMask[i], tmp);

-      }

-   }

-

-   if (ctx->Driver.ColorMask)

-      ctx->Driver.ColorMask( ctx, red, green, blue, alpha );

-}

-

-

-/**

- * For GL_EXT_draw_buffers2 and GL3

- */

-void GLAPIENTRY

-_mesa_ColorMaskIndexed( GLuint buf, GLboolean red, GLboolean green,

-                        GLboolean blue, GLboolean alpha )

-{

-   GLubyte tmp[4];

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glColorMaskIndexed %u %d %d %d %d\n",

-                  buf, red, green, blue, alpha);

-

-   if (buf >= ctx->Const.MaxDrawBuffers) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glColorMaskIndexed(buf=%u)", buf);

-      return;

-   }

-

-   /* Shouldn't have any information about channel depth in core mesa

-    * -- should probably store these as the native booleans:

-    */

-   tmp[RCOMP] = red    ? 0xff : 0x0;

-   tmp[GCOMP] = green  ? 0xff : 0x0;

-   tmp[BCOMP] = blue   ? 0xff : 0x0;

-   tmp[ACOMP] = alpha  ? 0xff : 0x0;

-

-   if (TEST_EQ_4V(tmp, ctx->Color.ColorMask[buf]))

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   COPY_4UBV(ctx->Color.ColorMask[buf], tmp);

-

-   if (ctx->Driver.ColorMaskIndexed)

-      ctx->Driver.ColorMaskIndexed(ctx, buf, red, green, blue, alpha);

-}

-

-

-void GLAPIENTRY

-_mesa_ClampColorARB(GLenum target, GLenum clamp)

-{

-   GET_CURRENT_CONTEXT(ctx);

-

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (clamp != GL_TRUE && clamp != GL_FALSE && clamp != GL_FIXED_ONLY_ARB) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(clamp)");

-      return;

-   }

-

-   switch (target) {

-   case GL_CLAMP_VERTEX_COLOR_ARB:

-      FLUSH_VERTICES(ctx, _NEW_LIGHT);

-      ctx->Light.ClampVertexColor = clamp;

-      break;

-   case GL_CLAMP_FRAGMENT_COLOR_ARB:

-      FLUSH_VERTICES(ctx, _NEW_FRAG_CLAMP);

-      ctx->Color.ClampFragmentColor = clamp;

-      break;

-   case GL_CLAMP_READ_COLOR_ARB:

-      FLUSH_VERTICES(ctx, _NEW_COLOR);

-      ctx->Color.ClampReadColor = clamp;

-      break;

-   default:

-      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(target)");

-      return;

-   }

-}

-

-

-

-

-/**********************************************************************/

-/** \name Initialization */

-/*@{*/

-

-/**

- * Initialization of the context's Color attribute group.

- *

- * \param ctx GL context.

- *

- * Initializes the related fields in the context color attribute group,

- * __struct gl_contextRec::Color.

- */

-void _mesa_init_color( struct gl_context * ctx )

-{

-   GLuint i;

-

-   /* Color buffer group */

-   ctx->Color.IndexMask = ~0u;

-   memset(ctx->Color.ColorMask, 0xff, sizeof(ctx->Color.ColorMask));

-   ctx->Color.ClearIndex = 0;

-   ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );

-   ASSIGN_4V( ctx->Color.ClearColorUnclamped, 0, 0, 0, 0 );

-   ctx->Color.AlphaEnabled = GL_FALSE;

-   ctx->Color.AlphaFunc = GL_ALWAYS;

-   ctx->Color.AlphaRef = 0;

-   ctx->Color.BlendEnabled = 0x0;

-   for (i = 0; i < Elements(ctx->Color.Blend); i++) {

-      ctx->Color.Blend[i].SrcRGB = GL_ONE;

-      ctx->Color.Blend[i].DstRGB = GL_ZERO;

-      ctx->Color.Blend[i].SrcA = GL_ONE;

-      ctx->Color.Blend[i].DstA = GL_ZERO;

-      ctx->Color.Blend[i].EquationRGB = GL_FUNC_ADD;

-      ctx->Color.Blend[i].EquationA = GL_FUNC_ADD;

-   }

-   ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );

-   ASSIGN_4V( ctx->Color.BlendColorUnclamped, 0.0, 0.0, 0.0, 0.0 );

-   ctx->Color.IndexLogicOpEnabled = GL_FALSE;

-   ctx->Color.ColorLogicOpEnabled = GL_FALSE;

-   ctx->Color._LogicOpEnabled = GL_FALSE;

-   ctx->Color.LogicOp = GL_COPY;

-   ctx->Color.DitherFlag = GL_TRUE;

-

-   if (ctx->Visual.doubleBufferMode) {

-      ctx->Color.DrawBuffer[0] = GL_BACK;

-   }

-   else {

-      ctx->Color.DrawBuffer[0] = GL_FRONT;

-   }

-

-   ctx->Color.ClampFragmentColor = GL_FIXED_ONLY_ARB;

-   ctx->Color._ClampFragmentColor = GL_TRUE;

-   ctx->Color.ClampReadColor = GL_FIXED_ONLY_ARB;

-   ctx->Color._ClampReadColor = GL_TRUE;

-}

-

-/*@}*/

+/**
+ * \file blend.c
+ * Blending operations.
+ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5.1
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+
+#include "glheader.h"
+#include "blend.h"
+#include "context.h"
+#include "enums.h"
+#include "macros.h"
+#include "mtypes.h"
+
+
+
+/**
+ * Check if given blend source factor is legal.
+ * \return GL_TRUE if legal, GL_FALSE otherwise.
+ */
+static GLboolean
+legal_src_factor(const struct gl_context *ctx, GLenum factor)
+{
+   switch (factor) {
+   case GL_SRC_COLOR:
+   case GL_ONE_MINUS_SRC_COLOR:
+      return ctx->Extensions.NV_blend_square;
+   case GL_ZERO:
+   case GL_ONE:
+   case GL_DST_COLOR:
+   case GL_ONE_MINUS_DST_COLOR:
+   case GL_SRC_ALPHA:
+   case GL_ONE_MINUS_SRC_ALPHA:
+   case GL_DST_ALPHA:
+   case GL_ONE_MINUS_DST_ALPHA:
+   case GL_SRC_ALPHA_SATURATE:
+   case GL_CONSTANT_COLOR:
+   case GL_ONE_MINUS_CONSTANT_COLOR:
+   case GL_CONSTANT_ALPHA:
+   case GL_ONE_MINUS_CONSTANT_ALPHA:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+/**
+ * Check if given blend destination factor is legal.
+ * \return GL_TRUE if legal, GL_FALSE otherwise.
+ */
+static GLboolean
+legal_dst_factor(const struct gl_context *ctx, GLenum factor)
+{
+   switch (factor) {
+   case GL_DST_COLOR:
+   case GL_ONE_MINUS_DST_COLOR:
+      return ctx->Extensions.NV_blend_square;
+   case GL_ZERO:
+   case GL_ONE:
+   case GL_SRC_COLOR:
+   case GL_ONE_MINUS_SRC_COLOR:
+   case GL_SRC_ALPHA:
+   case GL_ONE_MINUS_SRC_ALPHA:
+   case GL_DST_ALPHA:
+   case GL_ONE_MINUS_DST_ALPHA:
+   case GL_CONSTANT_COLOR:
+   case GL_ONE_MINUS_CONSTANT_COLOR:
+   case GL_CONSTANT_ALPHA:
+   case GL_ONE_MINUS_CONSTANT_ALPHA:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+/**
+ * Check if src/dest RGB/A blend factors are legal.  If not generate
+ * a GL error.
+ * \return GL_TRUE if factors are legal, GL_FALSE otherwise.
+ */
+static GLboolean
+validate_blend_factors(struct gl_context *ctx, const char *func,
+                       GLenum sfactorRGB, GLenum dfactorRGB,
+                       GLenum sfactorA, GLenum dfactorA)
+{
+   if (!legal_src_factor(ctx, sfactorRGB)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(sfactorRGB = %s)", func,
+                  _mesa_lookup_enum_by_nr(sfactorRGB));
+      return GL_FALSE;
+   }
+
+   if (!legal_dst_factor(ctx, dfactorRGB)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(dfactorRGB = %s)", func,
+                  _mesa_lookup_enum_by_nr(dfactorRGB));
+      return GL_FALSE;
+   }
+
+   if (sfactorA != sfactorRGB && !legal_src_factor(ctx, sfactorA)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(sfactorA = %s)", func,
+                  _mesa_lookup_enum_by_nr(sfactorA));
+      return GL_FALSE;
+   }
+
+   if (dfactorA != dfactorRGB && !legal_dst_factor(ctx, dfactorA)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(dfactorA = %s)", func,
+                  _mesa_lookup_enum_by_nr(dfactorA));
+      return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
+
+
+/**
+ * Specify the blending operation.
+ *
+ * \param sfactor source factor operator.
+ * \param dfactor destination factor operator.
+ *
+ * \sa glBlendFunc, glBlendFuncSeparateEXT
+ */
+void GLAPIENTRY
+_mesa_BlendFunc( GLenum sfactor, GLenum dfactor )
+{
+   _mesa_BlendFuncSeparateEXT(sfactor, dfactor, sfactor, dfactor);
+}
+
+
+/**
+ * Set the separate blend source/dest factors for all draw buffers.
+ *
+ * \param sfactorRGB RGB source factor operator.
+ * \param dfactorRGB RGB destination factor operator.
+ * \param sfactorA alpha source factor operator.
+ * \param dfactorA alpha destination factor operator.
+ */
+void GLAPIENTRY
+_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,
+                            GLenum sfactorA, GLenum dfactorA )
+{
+   GLuint buf, numBuffers;
+   GLboolean changed;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glBlendFuncSeparate %s %s %s %s\n",
+                  _mesa_lookup_enum_by_nr(sfactorRGB),
+                  _mesa_lookup_enum_by_nr(dfactorRGB),
+                  _mesa_lookup_enum_by_nr(sfactorA),
+                  _mesa_lookup_enum_by_nr(dfactorA));
+
+   if (!validate_blend_factors(ctx, "glBlendFuncSeparate",
+                               sfactorRGB, dfactorRGB,
+                               sfactorA, dfactorA)) {
+      return;
+   }
+
+   numBuffers = ctx->Extensions.ARB_draw_buffers_blend
+      ? ctx->Const.MaxDrawBuffers : 1;
+
+   changed = GL_FALSE;
+   for (buf = 0; buf < numBuffers; buf++) {
+      if (ctx->Color.Blend[buf].SrcRGB != sfactorRGB ||
+          ctx->Color.Blend[buf].DstRGB != dfactorRGB ||
+          ctx->Color.Blend[buf].SrcA != sfactorA ||
+          ctx->Color.Blend[buf].DstA != dfactorA) {
+         changed = GL_TRUE;
+         break;
+      }
+   }
+   if (!changed)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+
+   for (buf = 0; buf < numBuffers; buf++) {
+      ctx->Color.Blend[buf].SrcRGB = sfactorRGB;
+      ctx->Color.Blend[buf].DstRGB = dfactorRGB;
+      ctx->Color.Blend[buf].SrcA = sfactorA;
+      ctx->Color.Blend[buf].DstA = dfactorA;
+   }
+   ctx->Color._BlendFuncPerBuffer = GL_FALSE;
+
+   if (ctx->Driver.BlendFuncSeparate) {
+      ctx->Driver.BlendFuncSeparate(ctx, sfactorRGB, dfactorRGB,
+                                    sfactorA, dfactorA);
+   }
+}
+
+
+#if _HAVE_FULL_GL
+
+
+/**
+ * Set blend source/dest factors for one color buffer/target.
+ */
+void GLAPIENTRY
+_mesa_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)
+{
+   _mesa_BlendFuncSeparatei(buf, sfactor, dfactor, sfactor, dfactor);
+}
+
+
+/**
+ * Set separate blend source/dest factors for one color buffer/target.
+ */
+void GLAPIENTRY
+_mesa_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,
+                         GLenum sfactorA, GLenum dfactorA)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ARB_draw_buffers_blend) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendFunc[Separate]i()");
+      return;
+   }
+
+   if (buf >= ctx->Const.MaxDrawBuffers) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",
+                  buf);
+      return;
+   }
+
+   if (!validate_blend_factors(ctx, "glBlendFuncSeparatei",
+                               sfactorRGB, dfactorRGB,
+                               sfactorA, dfactorA)) {
+      return;
+   }
+
+   if (ctx->Color.Blend[buf].SrcRGB == sfactorRGB &&
+       ctx->Color.Blend[buf].DstRGB == dfactorRGB &&
+       ctx->Color.Blend[buf].SrcA == sfactorA &&
+       ctx->Color.Blend[buf].DstA == dfactorA)
+      return; /* no change */
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+
+   ctx->Color.Blend[buf].SrcRGB = sfactorRGB;
+   ctx->Color.Blend[buf].DstRGB = dfactorRGB;
+   ctx->Color.Blend[buf].SrcA = sfactorA;
+   ctx->Color.Blend[buf].DstA = dfactorA;
+   ctx->Color._BlendFuncPerBuffer = GL_TRUE;
+
+   if (ctx->Driver.BlendFuncSeparatei) {
+      ctx->Driver.BlendFuncSeparatei(ctx, buf, sfactorRGB, dfactorRGB,
+                                     sfactorA, dfactorA);
+   }
+}
+
+
+/**
+ * Check if given blend equation is legal.
+ * \return GL_TRUE if legal, GL_FALSE otherwise.
+ */
+static GLboolean
+legal_blend_equation(const struct gl_context *ctx,
+                     GLenum mode, GLboolean is_separate)
+{
+   switch (mode) {
+   case GL_FUNC_ADD:
+      return GL_TRUE;
+   case GL_MIN:
+   case GL_MAX:
+      return ctx->Extensions.EXT_blend_minmax;
+   case GL_LOGIC_OP:
+      /* glBlendEquationSeparate cannot take GL_LOGIC_OP as a parameter.
+       */
+      return ctx->Extensions.EXT_blend_logic_op && !is_separate;
+   case GL_FUNC_SUBTRACT:
+   case GL_FUNC_REVERSE_SUBTRACT:
+      return ctx->Extensions.EXT_blend_subtract;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+/* This is really an extension function! */
+void GLAPIENTRY
+_mesa_BlendEquation( GLenum mode )
+{
+   GLuint buf, numBuffers;
+   GLboolean changed;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glBlendEquation(%s)\n",
+                  _mesa_lookup_enum_by_nr(mode));
+
+   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");
+      return;
+   }
+
+   numBuffers = ctx->Extensions.ARB_draw_buffers_blend
+      ? ctx->Const.MaxDrawBuffers : 1;
+
+   changed = GL_FALSE;
+   for (buf = 0; buf < numBuffers; buf++) {
+      if (ctx->Color.Blend[buf].EquationRGB != mode ||
+          ctx->Color.Blend[buf].EquationA != mode) {
+         changed = GL_TRUE;
+         break;
+      }
+   }
+   if (!changed)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   for (buf = 0; buf < numBuffers; buf++) {
+      ctx->Color.Blend[buf].EquationRGB = mode;
+      ctx->Color.Blend[buf].EquationA = mode;
+   }
+   ctx->Color._BlendEquationPerBuffer = GL_FALSE;
+
+   if (ctx->Driver.BlendEquationSeparate)
+      (*ctx->Driver.BlendEquationSeparate)( ctx, mode, mode );
+}
+
+
+/**
+ * Set blend equation for one color buffer/target.
+ */
+void GLAPIENTRY
+_mesa_BlendEquationi(GLuint buf, GLenum mode)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glBlendEquationi(%u, %s)\n",
+                  buf, _mesa_lookup_enum_by_nr(mode));
+
+   if (buf >= ctx->Const.MaxDrawBuffers) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",
+                  buf);
+      return;
+   }
+
+   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationi");
+      return;
+   }
+
+   if (ctx->Color.Blend[buf].EquationRGB == mode &&
+       ctx->Color.Blend[buf].EquationA == mode)
+      return;  /* no change */
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.Blend[buf].EquationRGB = mode;
+   ctx->Color.Blend[buf].EquationA = mode;
+   ctx->Color._BlendEquationPerBuffer = GL_TRUE;
+
+   if (ctx->Driver.BlendEquationSeparatei)
+      ctx->Driver.BlendEquationSeparatei(ctx, buf, mode, mode);
+}
+
+
+void GLAPIENTRY
+_mesa_BlendEquationSeparateEXT( GLenum modeRGB, GLenum modeA )
+{
+   GLuint buf, numBuffers;
+   GLboolean changed;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glBlendEquationSeparateEXT(%s %s)\n",
+                  _mesa_lookup_enum_by_nr(modeRGB),
+                  _mesa_lookup_enum_by_nr(modeA));
+
+   if ( (modeRGB != modeA) && !ctx->Extensions.EXT_blend_equation_separate ) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+		  "glBlendEquationSeparateEXT not supported by driver");
+      return;
+   }
+
+   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeRGB)");
+      return;
+   }
+
+   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeA)");
+      return;
+   }
+
+   numBuffers = ctx->Extensions.ARB_draw_buffers_blend
+      ? ctx->Const.MaxDrawBuffers : 1;
+
+   changed = GL_FALSE;
+   for (buf = 0; buf < numBuffers; buf++) {
+      if (ctx->Color.Blend[buf].EquationRGB != modeRGB ||
+          ctx->Color.Blend[buf].EquationA != modeA) {
+         changed = GL_TRUE;
+         break;
+      }
+   }
+   if (!changed)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   for (buf = 0; buf < numBuffers; buf++) {
+      ctx->Color.Blend[buf].EquationRGB = modeRGB;
+      ctx->Color.Blend[buf].EquationA = modeA;
+   }
+   ctx->Color._BlendEquationPerBuffer = GL_FALSE;
+
+   if (ctx->Driver.BlendEquationSeparate)
+      ctx->Driver.BlendEquationSeparate(ctx, modeRGB, modeA);
+}
+
+
+/**
+ * Set separate blend equations for one color buffer/target.
+ */
+void GLAPIENTRY
+_mesa_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glBlendEquationSeparatei(%u, %s %s)\n", buf,
+                  _mesa_lookup_enum_by_nr(modeRGB),
+                  _mesa_lookup_enum_by_nr(modeA));
+
+   if (buf >= ctx->Const.MaxDrawBuffers) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendEquationSeparatei(buffer=%u)",
+                  buf);
+      return;
+   }
+
+   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeRGB)");
+      return;
+   }
+
+   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeA)");
+      return;
+   }
+
+   if (ctx->Color.Blend[buf].EquationRGB == modeRGB &&
+       ctx->Color.Blend[buf].EquationA == modeA)
+      return;  /* no change */
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.Blend[buf].EquationRGB = modeRGB;
+   ctx->Color.Blend[buf].EquationA = modeA;
+   ctx->Color._BlendEquationPerBuffer = GL_TRUE;
+
+   if (ctx->Driver.BlendEquationSeparatei)
+      ctx->Driver.BlendEquationSeparatei(ctx, buf, modeRGB, modeA);
+}
+
+
+
+#endif /* _HAVE_FULL_GL */
+
+
+/**
+ * Set the blending color.
+ *
+ * \param red red color component.
+ * \param green green color component.
+ * \param blue blue color component.
+ * \param alpha alpha color component.
+ *
+ * \sa glBlendColor().
+ *
+ * Clamps the parameters and updates gl_colorbuffer_attrib::BlendColor.  On a
+ * change, flushes the vertices and notifies the driver via
+ * dd_function_table::BlendColor callback.
+ */
+void GLAPIENTRY
+_mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+{
+   GLfloat tmp[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   tmp[0] = red;
+   tmp[1] = green;
+   tmp[2] = blue;
+   tmp[3] = alpha;
+
+   if (TEST_EQ_4V(tmp, ctx->Color.BlendColorUnclamped))
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4FV( ctx->Color.BlendColorUnclamped, tmp );
+
+   ctx->Color.BlendColor[0] = CLAMP(tmp[0], 0.0F, 1.0F);
+   ctx->Color.BlendColor[1] = CLAMP(tmp[1], 0.0F, 1.0F);
+   ctx->Color.BlendColor[2] = CLAMP(tmp[2], 0.0F, 1.0F);
+   ctx->Color.BlendColor[3] = CLAMP(tmp[3], 0.0F, 1.0F);
+
+   if (ctx->Driver.BlendColor)
+      (*ctx->Driver.BlendColor)(ctx, ctx->Color.BlendColor);
+}
+
+
+/**
+ * Specify the alpha test function.
+ *
+ * \param func alpha comparison function.
+ * \param ref reference value.
+ *
+ * Verifies the parameters and updates gl_colorbuffer_attrib. 
+ * On a change, flushes the vertices and notifies the driver via
+ * dd_function_table::AlphaFunc callback.
+ */
+void GLAPIENTRY
+_mesa_AlphaFunc( GLenum func, GLclampf ref )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glAlphaFunc(%s, %f)\n",
+                  _mesa_lookup_enum_by_nr(func), ref);
+
+   switch (func) {
+   case GL_NEVER:
+   case GL_LESS:
+   case GL_EQUAL:
+   case GL_LEQUAL:
+   case GL_GREATER:
+   case GL_NOTEQUAL:
+   case GL_GEQUAL:
+   case GL_ALWAYS:
+      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRefUnclamped == ref)
+         return; /* no change */
+
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.AlphaFunc = func;
+      ctx->Color.AlphaRefUnclamped = ref;
+      ctx->Color.AlphaRef = CLAMP(ref, 0.0F, 1.0F);
+
+      if (ctx->Driver.AlphaFunc)
+         ctx->Driver.AlphaFunc(ctx, func, ctx->Color.AlphaRef);
+      return;
+
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );
+      return;
+   }
+}
+
+
+/**
+ * Specify a logic pixel operation for color index rendering.
+ *
+ * \param opcode operation.
+ *
+ * Verifies that \p opcode is a valid enum and updates
+gl_colorbuffer_attrib::LogicOp.
+ * On a change, flushes the vertices and notifies the driver via the
+ * dd_function_table::LogicOpcode callback.
+ */
+void GLAPIENTRY
+_mesa_LogicOp( GLenum opcode )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glLogicOp(%s)\n", _mesa_lookup_enum_by_nr(opcode));
+
+   switch (opcode) {
+      case GL_CLEAR:
+      case GL_SET:
+      case GL_COPY:
+      case GL_COPY_INVERTED:
+      case GL_NOOP:
+      case GL_INVERT:
+      case GL_AND:
+      case GL_NAND:
+      case GL_OR:
+      case GL_NOR:
+      case GL_XOR:
+      case GL_EQUIV:
+      case GL_AND_REVERSE:
+      case GL_AND_INVERTED:
+      case GL_OR_REVERSE:
+      case GL_OR_INVERTED:
+	 break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
+	 return;
+   }
+
+   if (ctx->Color.LogicOp == opcode)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.LogicOp = opcode;
+
+   if (ctx->Driver.LogicOpcode)
+      ctx->Driver.LogicOpcode( ctx, opcode );
+}
+
+#if _HAVE_FULL_GL
+void GLAPIENTRY
+_mesa_IndexMask( GLuint mask )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->Color.IndexMask == mask)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.IndexMask = mask;
+}
+#endif
+
+
+/**
+ * Enable or disable writing of frame buffer color components.
+ *
+ * \param red whether to mask writing of the red color component.
+ * \param green whether to mask writing of the green color component.
+ * \param blue whether to mask writing of the blue color component.
+ * \param alpha whether to mask writing of the alpha color component.
+ *
+ * \sa glColorMask().
+ *
+ * Sets the appropriate value of gl_colorbuffer_attrib::ColorMask.  On a
+ * change, flushes the vertices and notifies the driver via the
+ * dd_function_table::ColorMask callback.
+ */
+void GLAPIENTRY
+_mesa_ColorMask( GLboolean red, GLboolean green,
+                 GLboolean blue, GLboolean alpha )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLubyte tmp[4];
+   GLuint i;
+   GLboolean flushed;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glColorMask(%d, %d, %d, %d)\n",
+                  red, green, blue, alpha);
+
+   /* Shouldn't have any information about channel depth in core mesa
+    * -- should probably store these as the native booleans:
+    */
+   tmp[RCOMP] = red    ? 0xff : 0x0;
+   tmp[GCOMP] = green  ? 0xff : 0x0;
+   tmp[BCOMP] = blue   ? 0xff : 0x0;
+   tmp[ACOMP] = alpha  ? 0xff : 0x0;
+
+   flushed = GL_FALSE;
+   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
+      if (!TEST_EQ_4V(tmp, ctx->Color.ColorMask[i])) {
+         if (!flushed) {
+            FLUSH_VERTICES(ctx, _NEW_COLOR);
+         }
+         flushed = GL_TRUE;
+         COPY_4UBV(ctx->Color.ColorMask[i], tmp);
+      }
+   }
+
+   if (ctx->Driver.ColorMask)
+      ctx->Driver.ColorMask( ctx, red, green, blue, alpha );
+}
+
+
+/**
+ * For GL_EXT_draw_buffers2 and GL3
+ */
+void GLAPIENTRY
+_mesa_ColorMaskIndexed( GLuint buf, GLboolean red, GLboolean green,
+                        GLboolean blue, GLboolean alpha )
+{
+   GLubyte tmp[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glColorMaskIndexed %u %d %d %d %d\n",
+                  buf, red, green, blue, alpha);
+
+   if (buf >= ctx->Const.MaxDrawBuffers) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glColorMaskIndexed(buf=%u)", buf);
+      return;
+   }
+
+   /* Shouldn't have any information about channel depth in core mesa
+    * -- should probably store these as the native booleans:
+    */
+   tmp[RCOMP] = red    ? 0xff : 0x0;
+   tmp[GCOMP] = green  ? 0xff : 0x0;
+   tmp[BCOMP] = blue   ? 0xff : 0x0;
+   tmp[ACOMP] = alpha  ? 0xff : 0x0;
+
+   if (TEST_EQ_4V(tmp, ctx->Color.ColorMask[buf]))
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4UBV(ctx->Color.ColorMask[buf], tmp);
+
+   if (ctx->Driver.ColorMaskIndexed)
+      ctx->Driver.ColorMaskIndexed(ctx, buf, red, green, blue, alpha);
+}
+
+
+void GLAPIENTRY
+_mesa_ClampColorARB(GLenum target, GLenum clamp)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (clamp != GL_TRUE && clamp != GL_FALSE && clamp != GL_FIXED_ONLY_ARB) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(clamp)");
+      return;
+   }
+
+   switch (target) {
+   case GL_CLAMP_VERTEX_COLOR_ARB:
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      ctx->Light.ClampVertexColor = clamp;
+      break;
+   case GL_CLAMP_FRAGMENT_COLOR_ARB:
+      FLUSH_VERTICES(ctx, _NEW_FRAG_CLAMP);
+      ctx->Color.ClampFragmentColor = clamp;
+      break;
+   case GL_CLAMP_READ_COLOR_ARB:
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.ClampReadColor = clamp;
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(target)");
+      return;
+   }
+}
+
+
+
+
+/**********************************************************************/
+/** \name Initialization */
+/*@{*/
+
+/**
+ * Initialization of the context's Color attribute group.
+ *
+ * \param ctx GL context.
+ *
+ * Initializes the related fields in the context color attribute group,
+ * __struct gl_contextRec::Color.
+ */
+void _mesa_init_color( struct gl_context * ctx )
+{
+   GLuint i;
+
+   /* Color buffer group */
+   ctx->Color.IndexMask = ~0u;
+   memset(ctx->Color.ColorMask, 0xff, sizeof(ctx->Color.ColorMask));
+   ctx->Color.ClearIndex = 0;
+   ASSIGN_4V( ctx->Color.ClearColor.f, 0, 0, 0, 0 );
+   ctx->Color.AlphaEnabled = GL_FALSE;
+   ctx->Color.AlphaFunc = GL_ALWAYS;
+   ctx->Color.AlphaRef = 0;
+   ctx->Color.BlendEnabled = 0x0;
+   for (i = 0; i < Elements(ctx->Color.Blend); i++) {
+      ctx->Color.Blend[i].SrcRGB = GL_ONE;
+      ctx->Color.Blend[i].DstRGB = GL_ZERO;
+      ctx->Color.Blend[i].SrcA = GL_ONE;
+      ctx->Color.Blend[i].DstA = GL_ZERO;
+      ctx->Color.Blend[i].EquationRGB = GL_FUNC_ADD;
+      ctx->Color.Blend[i].EquationA = GL_FUNC_ADD;
+   }
+   ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Color.BlendColorUnclamped, 0.0, 0.0, 0.0, 0.0 );
+   ctx->Color.IndexLogicOpEnabled = GL_FALSE;
+   ctx->Color.ColorLogicOpEnabled = GL_FALSE;
+   ctx->Color._LogicOpEnabled = GL_FALSE;
+   ctx->Color.LogicOp = GL_COPY;
+   ctx->Color.DitherFlag = GL_TRUE;
+
+   if (ctx->Visual.doubleBufferMode) {
+      ctx->Color.DrawBuffer[0] = GL_BACK;
+   }
+   else {
+      ctx->Color.DrawBuffer[0] = GL_FRONT;
+   }
+
+   ctx->Color.ClampFragmentColor = GL_FIXED_ONLY_ARB;
+   ctx->Color._ClampFragmentColor = GL_TRUE;
+   ctx->Color.ClampReadColor = GL_FIXED_ONLY_ARB;
+   ctx->Color._ClampReadColor = GL_TRUE;
+}
+
+/*@}*/
diff --git a/mesalib/src/mesa/main/clear.c b/mesalib/src/mesa/main/clear.c
index fa95e4522..301fe694c 100644
--- a/mesalib/src/mesa/main/clear.c
+++ b/mesalib/src/mesa/main/clear.c
@@ -83,16 +83,11 @@ _mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
    tmp[2] = blue;
    tmp[3] = alpha;
 
-   if (TEST_EQ_4V(tmp, ctx->Color.ClearColorUnclamped))
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor.f))
       return; /* no change */
 
    FLUSH_VERTICES(ctx, _NEW_COLOR);
-   COPY_4V(ctx->Color.ClearColorUnclamped, tmp);
-
-   ctx->Color.ClearColor[0] = CLAMP(tmp[0], 0.0F, 1.0F);
-   ctx->Color.ClearColor[1] = CLAMP(tmp[1], 0.0F, 1.0F);
-   ctx->Color.ClearColor[2] = CLAMP(tmp[2], 0.0F, 1.0F);
-   ctx->Color.ClearColor[3] = CLAMP(tmp[3], 0.0F, 1.0F);
+   COPY_4V(ctx->Color.ClearColor.f, tmp);
 
    if (ctx->Driver.ClearColor) {
       /* it's OK to call glClearColor in CI mode but it should be a NOP */
@@ -110,25 +105,22 @@ _mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 void GLAPIENTRY
 _mesa_ClearColorIiEXT(GLint r, GLint g, GLint b, GLint a)
 {
-   GLfloat tmp[4];
+   GLint tmp[4];
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   tmp[0] = (GLfloat) r;
-   tmp[1] = (GLfloat) g;
-   tmp[2] = (GLfloat) b;
-   tmp[3] = (GLfloat) a;
+   tmp[0] = r;
+   tmp[1] = g;
+   tmp[2] = b;
+   tmp[3] = a;
 
-   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor.i))
       return; /* no change */
 
    FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4V(ctx->Color.ClearColor.i, tmp);
 
-   /* XXX we should eventually have a float/int/uint union for
-    * the ctx->Color.ClearColor state.
-    */
-   COPY_4V(ctx->Color.ClearColor, tmp);
-
+   /* these should be NOP calls for drivers supporting EXT_texture_integer */
    if (ctx->Driver.ClearColor) {
       ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
    }
@@ -141,25 +133,22 @@ _mesa_ClearColorIiEXT(GLint r, GLint g, GLint b, GLint a)
 void GLAPIENTRY
 _mesa_ClearColorIuiEXT(GLuint r, GLuint g, GLuint b, GLuint a)
 {
-   GLfloat tmp[4];
+   GLuint tmp[4];
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   tmp[0] = (GLfloat) r;
-   tmp[1] = (GLfloat) g;
-   tmp[2] = (GLfloat) b;
-   tmp[3] = (GLfloat) a;
+   tmp[0] = r;
+   tmp[1] = g;
+   tmp[2] = b;
+   tmp[3] = a;
 
-   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor.ui))
       return; /* no change */
 
    FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4V(ctx->Color.ClearColor.ui, tmp);
 
-   /* XXX we should eventually have a float/int/uint union for
-    * the ctx->Color.ClearColor state.
-    */
-   COPY_4V(ctx->Color.ClearColor, tmp);
-
+   /* these should be NOP calls for drivers supporting EXT_texture_integer */
    if (ctx->Driver.ClearColor) {
       ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
    }
@@ -364,21 +353,18 @@ _mesa_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
             return;
          }
          else if (mask) {
-            /* XXX note: we're putting the integer clear values into the
-             * floating point state var.  This will not always work.  We'll
-             * need a new ctx->Driver.ClearBuffer() hook....
-             */
-            GLclampf clearSave[4];
+            union gl_color_union clearSave;
+
             /* save color */
-            COPY_4V(clearSave, ctx->Color.ClearColor);
+            clearSave = ctx->Color.ClearColor;
             /* set color */
-            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);
+            COPY_4V(ctx->Color.ClearColor.i, value);
             if (ctx->Driver.ClearColor)
                ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
             /* clear buffer(s) */
             ctx->Driver.Clear(ctx, mask);
             /* restore color */
-            COPY_4V(ctx->Color.ClearColor, clearSave);
+            ctx->Color.ClearColor = clearSave;
             if (ctx->Driver.ClearColor)
                ctx->Driver.ClearColor(ctx, clearSave);
          }
@@ -418,21 +404,18 @@ _mesa_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
             return;
          }
          else if (mask) {
-            /* XXX note: we're putting the uint clear values into the
-             * floating point state var.  This will not always work.  We'll
-             * need a new ctx->Driver.ClearBuffer() hook....
-             */
-            GLclampf clearSave[4];
+            union gl_color_union clearSave;
+
             /* save color */
-            COPY_4V(clearSave, ctx->Color.ClearColor);
+            clearSave = ctx->Color.ClearColor;
             /* set color */
-            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);
+            COPY_4V(ctx->Color.ClearColor.ui, value);
             if (ctx->Driver.ClearColor)
                ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
             /* clear buffer(s) */
             ctx->Driver.Clear(ctx, mask);
             /* restore color */
-            COPY_4V(ctx->Color.ClearColor, clearSave);
+            ctx->Color.ClearColor = clearSave;
             if (ctx->Driver.ClearColor)
                ctx->Driver.ClearColor(ctx, clearSave);
          }
@@ -495,17 +478,18 @@ _mesa_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
             return;
          }
          else if (mask) {
-            GLclampf clearSave[4];
+            union gl_color_union clearSave;
+
             /* save color */
-            COPY_4V(clearSave, ctx->Color.ClearColor);
+            clearSave = ctx->Color.ClearColor;
             /* set color */
-            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);
+            COPY_4V_CAST(ctx->Color.ClearColor.f, value, GLclampf);
             if (ctx->Driver.ClearColor)
                ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
             /* clear buffer(s) */
             ctx->Driver.Clear(ctx, mask);
             /* restore color */
-            COPY_4V(ctx->Color.ClearColor, clearSave);
+            ctx->Color.ClearColor = clearSave;
             if (ctx->Driver.ClearColor)
                ctx->Driver.ClearColor(ctx, clearSave);
          }
diff --git a/mesalib/src/mesa/main/colormac.h b/mesalib/src/mesa/main/colormac.h
index d308c48b6..4b7c3b4a0 100644
--- a/mesalib/src/mesa/main/colormac.h
+++ b/mesalib/src/mesa/main/colormac.h
@@ -169,6 +169,17 @@ do {						\
 } while (0)
 
 
+/**
+ * Convert four float values in [0,1] to ubytes in [0,255] with clamping.
+ */
+static inline void
+_mesa_unclamped_float_rgba_to_ubyte(GLubyte dst[4], const GLfloat src[4])
+{
+   int i;
+   for (i = 0; i < 4; i++)
+      UNCLAMPED_FLOAT_TO_UBYTE(dst[i], src[i]);
+}
+
 
 /**
  * \name Generic color packing macros.  All inputs should be GLubytes.
diff --git a/mesalib/src/mesa/main/dd.h b/mesalib/src/mesa/main/dd.h
index b77e4f092..d6cc0196d 100644
--- a/mesalib/src/mesa/main/dd.h
+++ b/mesalib/src/mesa/main/dd.h
@@ -589,7 +589,8 @@ struct dd_function_table {
                               GLenum sfactorRGB, GLenum dfactorRGB,
                               GLenum sfactorA, GLenum dfactorA);
    /** Specify clear values for the color buffers */
-   void (*ClearColor)(struct gl_context *ctx, const GLfloat color[4]);
+   void (*ClearColor)(struct gl_context *ctx,
+                      const union gl_color_union color);
    /** Specify the clear value for the depth buffer */
    void (*ClearDepth)(struct gl_context *ctx, GLclampd d);
    /** Specify the clear value for the stencil buffer */
diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c
index 069254b18..a777bd8c4 100644
--- a/mesalib/src/mesa/main/get.c
+++ b/mesalib/src/mesa/main/get.c
@@ -1673,10 +1673,13 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
          COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped);
       break;
    case GL_COLOR_CLEAR_VALUE:
-      if(ctx->Color._ClampFragmentColor)
-         COPY_4FV(v->value_float_4, ctx->Color.ClearColor);
-      else
-         COPY_4FV(v->value_float_4, ctx->Color.ClearColorUnclamped);
+      if(ctx->Color._ClampFragmentColor) {
+         v->value_float_4[0] = CLAMP(ctx->Color.ClearColor.f[0], 0.0F, 1.0F);
+         v->value_float_4[1] = CLAMP(ctx->Color.ClearColor.f[1], 0.0F, 1.0F);
+         v->value_float_4[2] = CLAMP(ctx->Color.ClearColor.f[2], 0.0F, 1.0F);
+         v->value_float_4[3] = CLAMP(ctx->Color.ClearColor.f[3], 0.0F, 1.0F);
+      } else
+         COPY_4FV(v->value_float_4, ctx->Color.ClearColor.f);
       break;
    case GL_BLEND_COLOR_EXT:
       if(ctx->Color._ClampFragmentColor)
diff --git a/mesalib/src/mesa/main/image.c b/mesalib/src/mesa/main/image.c
index 3e75e7c6b..66d7eec65 100644
--- a/mesalib/src/mesa/main/image.c
+++ b/mesalib/src/mesa/main/image.c
@@ -1513,12 +1513,8 @@ _mesa_convert_colors(GLenum srcType, const GLvoid *src,
          GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
          GLuint i;
          for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);
-            }
+            if (!mask || mask[i])
+               _mesa_unclamped_float_rgba_to_ubyte(dst1[i], src4[i]);
          }
          if (useTemp)
             memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index ae500b4c2..8671ecda9 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -721,16 +721,26 @@ struct gl_accum_attrib
 
 
 /**
+ * Used for storing clear color, texture border color, etc.
+ * The float values are typically unclamped.
+ */
+union gl_color_union
+{
+   GLfloat f[4];
+   GLint i[4];
+   GLuint ui[4];
+};
+
+
+/**
  * Color buffer attribute group (GL_COLOR_BUFFER_BIT).
  */
 struct gl_colorbuffer_attrib
 {
-   GLuint ClearIndex;			/**< Index to use for glClear */
-   GLfloat ClearColorUnclamped[4];              /**< Color to use for glClear*/
-   GLclampf ClearColor[4];               /**< Color to use for glClear */
-
-   GLuint IndexMask;			/**< Color index write mask */
-   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */
+   GLuint ClearIndex;                      /**< Index for glClear */
+   union gl_color_union ClearColor;        /**< Color for glClear, unclamped */
+   GLuint IndexMask;                       /**< Color index write mask */
+   GLubyte ColorMask[MAX_DRAW_BUFFERS][4]; /**< Each flag is 0xff or 0x0 */
 
    GLenum DrawBuffer[MAX_DRAW_BUFFERS];	/**< Which buffer to draw into */
 
@@ -750,8 +760,8 @@ struct gl_colorbuffer_attrib
    /*@{*/
    GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */
 
-   /* NOTE: this does _not_ depend on fragment clamping or any other clamping control,
-    * only on the fixed-pointness of the render target.
+   /* NOTE: this does _not_ depend on fragment clamping or any other clamping
+    * control, only on the fixed-pointness of the render target.
     * The query does however depend on fragment color clamping.
     */
    GLfloat BlendColorUnclamped[4];               /**< Blending color */
@@ -1356,11 +1366,7 @@ struct gl_sampler_object
    GLenum WrapR;		/**< R-axis texture image wrap mode */
    GLenum MinFilter;		/**< minification filter */
    GLenum MagFilter;		/**< magnification filter */
-   union {
-      GLfloat f[4];
-      GLuint ui[4];
-      GLint i[4];
-   } BorderColor;               /**< Interpreted according to texture format */
+   union gl_color_union BorderColor;  /**< Interpreted according to texture format */
    GLfloat MinLod;		/**< min lambda, OpenGL 1.2 */
    GLfloat MaxLod;		/**< max lambda, OpenGL 1.2 */
    GLfloat LodBias;		/**< OpenGL 1.4 */
diff --git a/mesalib/src/mesa/main/uniforms.c b/mesalib/src/mesa/main/uniforms.c
index b0f9c33b8..2323819aa 100644
--- a/mesalib/src/mesa/main/uniforms.c
+++ b/mesalib/src/mesa/main/uniforms.c
@@ -111,21 +111,43 @@ is_sampler_type(GLenum type)
 {
    switch (type) {
    case GL_SAMPLER_1D:
+   case GL_INT_SAMPLER_1D:
+   case GL_UNSIGNED_INT_SAMPLER_1D:
    case GL_SAMPLER_2D:
+   case GL_INT_SAMPLER_2D:
+   case GL_UNSIGNED_INT_SAMPLER_2D:
    case GL_SAMPLER_3D:
+   case GL_INT_SAMPLER_3D:
+   case GL_UNSIGNED_INT_SAMPLER_3D:
    case GL_SAMPLER_CUBE:
+   case GL_INT_SAMPLER_CUBE:
+   case GL_UNSIGNED_INT_SAMPLER_CUBE:
    case GL_SAMPLER_1D_SHADOW:
    case GL_SAMPLER_2D_SHADOW:
    case GL_SAMPLER_CUBE_SHADOW:
    case GL_SAMPLER_2D_RECT_ARB:
+   case GL_INT_SAMPLER_2D_RECT:
+   case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
    case GL_SAMPLER_2D_RECT_SHADOW_ARB:
    case GL_SAMPLER_1D_ARRAY_EXT:
+   case GL_INT_SAMPLER_1D_ARRAY:
+   case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
    case GL_SAMPLER_2D_ARRAY_EXT:
+   case GL_INT_SAMPLER_2D_ARRAY:
+   case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
    case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
    case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
    case GL_SAMPLER_CUBE_MAP_ARRAY:
    case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
    case GL_SAMPLER_BUFFER:
+   case GL_INT_SAMPLER_BUFFER:
+   case GL_UNSIGNED_INT_SAMPLER_BUFFER:
+   case GL_SAMPLER_2D_MULTISAMPLE:
+   case GL_INT_SAMPLER_2D_MULTISAMPLE:
+   case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+   case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+   case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+   case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
       return GL_TRUE;
    default:
       return GL_FALSE;