X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_atom_blend.c;h=dea50af678dab4d3ac8c9a5cd8fc4d12c8732b70;hb=be6227d29dcf443d9b8bae66d3d2f0b946874a83;hp=35c09c3e08fa1b36fbf3012f164908eb1410e7f3;hpb=c417a2c3f37a6a28947db5dc5aa240473d29dd19;p=mesa.git

diff --git a/src/mesa/state_tracker/st_atom_blend.c b/src/mesa/state_tracker/st_atom_blend.c
index 35c09c3e08f..dea50af678d 100644
--- a/src/mesa/state_tracker/st_atom_blend.c
+++ b/src/mesa/state_tracker/st_atom_blend.c
@@ -78,10 +78,10 @@ translate_blend(GLenum blend)
       return PIPE_BLENDFACTOR_CONST_COLOR;
    case GL_CONSTANT_ALPHA:
       return PIPE_BLENDFACTOR_CONST_ALPHA;
-      /*
+   case GL_SRC1_COLOR:
       return PIPE_BLENDFACTOR_SRC1_COLOR;
+   case GL_SRC1_ALPHA:
       return PIPE_BLENDFACTOR_SRC1_ALPHA;
-      */
    case GL_ZERO:
       return PIPE_BLENDFACTOR_ZERO;
    case GL_ONE_MINUS_SRC_COLOR:
@@ -96,10 +96,10 @@ translate_blend(GLenum blend)
       return PIPE_BLENDFACTOR_INV_CONST_COLOR;
    case GL_ONE_MINUS_CONSTANT_ALPHA:
       return PIPE_BLENDFACTOR_INV_CONST_ALPHA;
-      /*
+   case GL_ONE_MINUS_SRC1_COLOR:
       return PIPE_BLENDFACTOR_INV_SRC1_COLOR;
+   case GL_ONE_MINUS_SRC1_ALPHA:
       return PIPE_BLENDFACTOR_INV_SRC1_ALPHA;
-      */
    default:
       assert("invalid GL token in translate_blend()" == NULL);
       return 0;
@@ -152,47 +152,99 @@ translate_logicop(GLenum logicop)
    }
 }
 
+/**
+ * Figure out if colormasks are different per rt.
+ */
+static GLboolean
+colormask_per_rt(const struct gl_context *ctx)
+{
+   /* a bit suboptimal have to compare lots of values */
+   unsigned i;
+   for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {
+      if (memcmp(ctx->Color.ColorMask[0], ctx->Color.ColorMask[i], 4)) {
+         return GL_TRUE;
+      }
+   }
+   return GL_FALSE;
+}
+
+/**
+ * Figure out if blend enables/state are different per rt.
+ */
+static GLboolean
+blend_per_rt(const struct gl_context *ctx)
+{
+   if (ctx->Color.BlendEnabled &&
+      (ctx->Color.BlendEnabled != ((1 << ctx->Const.MaxDrawBuffers) - 1))) {
+      /* This can only happen if GL_EXT_draw_buffers2 is enabled */
+      return GL_TRUE;
+   }
+   if (ctx->Color._BlendFuncPerBuffer || ctx->Color._BlendEquationPerBuffer) {
+      /* this can only happen if GL_ARB_draw_buffers_blend is enabled */
+      return GL_TRUE;
+   }
+   return GL_FALSE;
+}
 
 static void 
 update_blend( struct st_context *st )
 {
    struct pipe_blend_state *blend = &st->state.blend;
+   const struct gl_context *ctx = st->ctx;
+   unsigned num_state = 1;
+   unsigned i, j;
 
    memset(blend, 0, sizeof(*blend));
 
-   if (st->ctx->Color.ColorLogicOpEnabled ||
-       (st->ctx->Color.BlendEnabled &&
-        st->ctx->Color.BlendEquationRGB == GL_LOGIC_OP)) {
+   if (blend_per_rt(ctx) || colormask_per_rt(ctx)) {
+      num_state = ctx->Const.MaxDrawBuffers;
+      blend->independent_blend_enable = 1;
+   }
+   if (ctx->Color.ColorLogicOpEnabled) {
       /* logicop enabled */
       blend->logicop_enable = 1;
-      blend->logicop_func = translate_logicop(st->ctx->Color.LogicOp);
+      blend->logicop_func = translate_logicop(ctx->Color.LogicOp);
    }
-   else if (st->ctx->Color.BlendEnabled) {
+   else if (ctx->Color.BlendEnabled) {
       /* blending enabled */
-      blend->blend_enable = 1;
-
-      blend->rgb_func = translate_blend(st->ctx->Color.BlendEquationRGB);
-      if (st->ctx->Color.BlendEquationRGB == GL_MIN ||
-          st->ctx->Color.BlendEquationRGB == GL_MAX) {
-         /* Min/max are special */
-         blend->rgb_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend->rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
-      }
-      else {
-         blend->rgb_src_factor = translate_blend(st->ctx->Color.BlendSrcRGB);
-         blend->rgb_dst_factor = translate_blend(st->ctx->Color.BlendDstRGB);
-      }
+      for (i = 0, j = 0; i < num_state; i++) {
 
-      blend->alpha_func = translate_blend(st->ctx->Color.BlendEquationA);
-      if (st->ctx->Color.BlendEquationA == GL_MIN ||
-          st->ctx->Color.BlendEquationA == GL_MAX) {
-         /* Min/max are special */
-         blend->alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend->alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
-      }
-      else {
-         blend->alpha_src_factor = translate_blend(st->ctx->Color.BlendSrcA);
-         blend->alpha_dst_factor = translate_blend(st->ctx->Color.BlendDstA);
+         blend->rt[i].blend_enable = (ctx->Color.BlendEnabled >> i) & 0x1;
+
+         if (ctx->Extensions.ARB_draw_buffers_blend)
+            j = i;
+
+         blend->rt[i].rgb_func =
+            translate_blend(ctx->Color.Blend[j].EquationRGB);
+
+         if (ctx->Color.Blend[i].EquationRGB == GL_MIN ||
+             ctx->Color.Blend[i].EquationRGB == GL_MAX) {
+            /* Min/max are special */
+            blend->rt[i].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
+            blend->rt[i].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
+         }
+         else {
+            blend->rt[i].rgb_src_factor =
+               translate_blend(ctx->Color.Blend[j].SrcRGB);
+            blend->rt[i].rgb_dst_factor =
+               translate_blend(ctx->Color.Blend[j].DstRGB);
+         }
+
+         blend->rt[i].alpha_func =
+            translate_blend(ctx->Color.Blend[j].EquationA);
+
+         if (ctx->Color.Blend[i].EquationA == GL_MIN ||
+             ctx->Color.Blend[i].EquationA == GL_MAX) {
+            /* Min/max are special */
+            blend->rt[i].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+            blend->rt[i].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
+         }
+         else {
+            blend->rt[i].alpha_src_factor =
+               translate_blend(ctx->Color.Blend[j].SrcA);
+            blend->rt[i].alpha_dst_factor =
+               translate_blend(ctx->Color.Blend[j].DstA);
+         }
       }
    }
    else {
@@ -200,23 +252,34 @@ update_blend( struct st_context *st )
    }
 
    /* Colormask - maybe reverse these bits? */
-   if (st->ctx->Color.ColorMask[0])
-      blend->colormask |= PIPE_MASK_R;
-   if (st->ctx->Color.ColorMask[1])
-      blend->colormask |= PIPE_MASK_G;
-   if (st->ctx->Color.ColorMask[2])
-      blend->colormask |= PIPE_MASK_B;
-   if (st->ctx->Color.ColorMask[3])
-      blend->colormask |= PIPE_MASK_A;
-
-   if (st->ctx->Color.DitherFlag)
+   for (i = 0; i < num_state; i++) {
+      if (ctx->Color.ColorMask[i][0])
+         blend->rt[i].colormask |= PIPE_MASK_R;
+      if (ctx->Color.ColorMask[i][1])
+         blend->rt[i].colormask |= PIPE_MASK_G;
+      if (ctx->Color.ColorMask[i][2])
+         blend->rt[i].colormask |= PIPE_MASK_B;
+      if (ctx->Color.ColorMask[i][3])
+         blend->rt[i].colormask |= PIPE_MASK_A;
+   }
+
+   if (ctx->Color.DitherFlag)
       blend->dither = 1;
 
+   if (ctx->Multisample.Enabled) {
+      /* unlike in gallium/d3d10 these operations are only performed
+         if msaa is enabled */
+      if (ctx->Multisample.SampleAlphaToCoverage)
+         blend->alpha_to_coverage = 1;
+      if (ctx->Multisample.SampleAlphaToOne)
+         blend->alpha_to_one = 1;
+   }
+
    cso_set_blend(st->cso_context, blend);
 
    {
       struct pipe_blend_color bc;
-      COPY_4FV(bc.color, st->ctx->Color.BlendColor);
+      COPY_4FV(bc.color, ctx->Color.BlendColorUnclamped);
       cso_set_blend_color(st->cso_context, &bc);
    }
 }
@@ -225,7 +288,7 @@ update_blend( struct st_context *st )
 const struct st_tracked_state st_update_blend = {
    "st_update_blend",					/* name */
    {							/* dirty */
-      (_NEW_COLOR),  /* XXX _NEW_BLEND someday? */	/* mesa */
+      (_NEW_COLOR | _NEW_MULTISAMPLE),  /* XXX _NEW_BLEND someday? */	/* mesa */
       0,						/* st */
    },
    update_blend,					/* update */