mesalib git update 16/1/2011

1 files changed, 344 insertions, 159 deletions

diff --git a/mesalib/src/mesa/main/blend.c b/mesalib/src/mesa/main/blend.c
index 10e384a40..30466cca3 100644
--- a/mesalib/src/mesa/main/blend.c
+++ b/mesalib/src/mesa/main/blend.c
@@ -37,6 +37,110 @@
 #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.

  *

@@ -53,21 +157,19 @@ _mesa_BlendFunc( GLenum sfactor, GLenum dfactor )
 

 

 /**

- * Process GL_EXT_blend_func_separate().

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

- *

- * Verifies the parameters and updates gl_colorbuffer_attrib.

- * On a change, flush the vertices and notify the driver via

- * dd_function_table::BlendFuncSeparate.

  */

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

 

@@ -78,165 +180,130 @@ _mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,
                   _mesa_lookup_enum_by_nr(sfactorA),

                   _mesa_lookup_enum_by_nr(dfactorA));

 

-   switch (sfactorRGB) {

-      case GL_SRC_COLOR:

-      case GL_ONE_MINUS_SRC_COLOR:

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

-            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (sfactorRGB)");

-            return;

-         }

-         /* fall-through */

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

-         break;

-      default:

-         _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (sfactorRGB)");

-         return;

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

+                               sfactorRGB, dfactorRGB,

+                               sfactorA, dfactorA)) {

+      return;

    }

 

-   switch (dfactorRGB) {

-      case GL_DST_COLOR:

-      case GL_ONE_MINUS_DST_COLOR:

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

-            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (dfactorRGB)");

-            return;

-         }

-         /* fall-through */

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

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

-      default:

-         _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (dfactorRGB)");

-         return;

+      }

    }

+   if (!changed)

+      return;

 

-   switch (sfactorA) {

-      case GL_SRC_COLOR:

-      case GL_ONE_MINUS_SRC_COLOR:

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

-            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (sfactorA)");

-            return;

-         }

-         /* fall-through */

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

-         break;

-      default:

-         _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (sfactorA)");

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

 

-   switch (dfactorA) {

-      case GL_DST_COLOR:

-      case GL_ONE_MINUS_DST_COLOR:

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

-            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (dfactorA)");

-            return;

-         }

-         /* fall-through */

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

-         break;

-      default:

-         _mesa_error( ctx, GL_INVALID_ENUM, "glBlendFunc or glBlendFuncSeparate (dfactorA)" );

-         return;

+   if (ctx->Driver.BlendFuncSeparate) {

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

+                                    sfactorA, dfactorA);

    }

+}

+

 

-   if (ctx->Color.BlendSrcRGB == sfactorRGB &&

-       ctx->Color.BlendDstRGB == dfactorRGB &&

-       ctx->Color.BlendSrcA == sfactorA &&

-       ctx->Color.BlendDstA == 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.BlendSrcRGB = sfactorRGB;

-   ctx->Color.BlendDstRGB = dfactorRGB;

-   ctx->Color.BlendSrcA = sfactorA;

-   ctx->Color.BlendDstA = dfactorA;

+   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.BlendFuncSeparate) {

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

-					sfactorA, dfactorA );

+   if (ctx->Driver.BlendFuncSeparatei) {

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

+                                     sfactorA, dfactorA);

    }

 }

 

 

-#if _HAVE_FULL_GL

-

+/**

+ * Check if given blend equation is legal.

+ * \return GL_TRUE if legal, GL_FALSE otherwise.

+ */

 static GLboolean

-_mesa_validate_blend_equation( struct gl_context *ctx,

-			       GLenum mode, GLboolean is_separate )

+legal_blend_equation(const struct gl_context *ctx,

+                     GLenum mode, GLboolean is_separate)

 {

    switch (mode) {

-      case GL_FUNC_ADD:

-         break;

-      case GL_MIN:

-      case GL_MAX:

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

-            return GL_FALSE;

-         }

-         break;

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

        */

-      case GL_LOGIC_OP:

-         if (!ctx->Extensions.EXT_blend_logic_op || is_separate) {

-            return GL_FALSE;

-         }

-         break;

-      case GL_FUNC_SUBTRACT:

-      case GL_FUNC_REVERSE_SUBTRACT:

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

-            return GL_FALSE;

-         }

-         break;

-      default:

-         return GL_FALSE;

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

    }

-

-   return GL_TRUE;

 }

 

 

@@ -244,6 +311,8 @@ _mesa_validate_blend_equation( struct gl_context *ctx,
 void GLAPIENTRY

 _mesa_BlendEquation( GLenum mode )

 {

+   GLuint buf, numBuffers;

+   GLboolean changed;

    GET_CURRENT_CONTEXT(ctx);

    ASSERT_OUTSIDE_BEGIN_END(ctx);

 

@@ -251,27 +320,80 @@ _mesa_BlendEquation( GLenum mode )
       _mesa_debug(ctx, "glBlendEquation %s\n",

                   _mesa_lookup_enum_by_nr(mode));

 

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

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

       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");

       return;

    }

 

-   if ( (ctx->Color.BlendEquationRGB == mode) &&

-	(ctx->Color.BlendEquationA == mode) )

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

-   ctx->Color.BlendEquationRGB = mode;

-   ctx->Color.BlendEquationA = mode;

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

 

@@ -286,29 +408,88 @@ _mesa_BlendEquationSeparateEXT( GLenum modeRGB, GLenum modeA )
       return;

    }

 

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

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

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

       return;

    }

 

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

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

 

-   if ( (ctx->Color.BlendEquationRGB == modeRGB) &&

-	(ctx->Color.BlendEquationA == modeA) )

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

-   ctx->Color.BlendEquationRGB = modeRGB;

-   ctx->Color.BlendEquationA = modeA;

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

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

 }

-#endif

+

+

+/**

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

+ */

+void

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

 

 

 /**

@@ -593,6 +774,8 @@ _mesa_ClampColorARB(GLenum target, GLenum clamp)
  */

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

@@ -602,12 +785,14 @@ void _mesa_init_color( struct gl_context * ctx )
    ctx->Color.AlphaFunc = GL_ALWAYS;

    ctx->Color.AlphaRef = 0;

    ctx->Color.BlendEnabled = 0x0;

-   ctx->Color.BlendSrcRGB = GL_ONE;

-   ctx->Color.BlendDstRGB = GL_ZERO;

-   ctx->Color.BlendSrcA = GL_ONE;

-   ctx->Color.BlendDstA = GL_ZERO;

-   ctx->Color.BlendEquationRGB = GL_FUNC_ADD;

-   ctx->Color.BlendEquationA = GL_FUNC_ADD;

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

    ctx->Color.IndexLogicOpEnabled = GL_FALSE;

    ctx->Color.ColorLogicOpEnabled = GL_FALSE;