mesa: Add "shader/" path to #include statements in shader parser/lexer sources

[mesa.git] / src / mesa / state_tracker / st_atom_blend.c

diff --git a/src/mesa/state_tracker/st_atom_blend.c b/src/mesa/state_tracker/st_atom_blend.c
index e0215c9eefe1029e008531ada9f831e886a1cb85..43e62c29f3e4fc65a70f687f056f811436c35848 100644 (file)
--- a/src/mesa/state_tracker/st_atom_blend.c
+++ b/src/mesa/state_tracker/st_atom_blend.c
@@ -34,16 +34,19 @@
 
 #include "st_context.h"
 #include "st_atom.h"
+
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "cso_cache/cso_context.h"
 
+#include "main/macros.h"
 
 /**
  * Convert GLenum blend tokens to pipe tokens.
  * Both blend factors and blend funcs are accepted.
  */
 static GLuint
-gl_blend_to_sp(GLenum blend)
+translate_blend(GLenum blend)
 {
    switch (blend) {
    /* blend functions */
@@ -86,9 +89,9 @@ gl_blend_to_sp(GLenum blend)
    case GL_ONE_MINUS_SRC_ALPHA:
       return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
    case GL_ONE_MINUS_DST_COLOR:
-      return PIPE_BLENDFACTOR_INV_DST_ALPHA;
-   case GL_ONE_MINUS_DST_ALPHA:
       return PIPE_BLENDFACTOR_INV_DST_COLOR;
+   case GL_ONE_MINUS_DST_ALPHA:
+      return PIPE_BLENDFACTOR_INV_DST_ALPHA;
    case GL_ONE_MINUS_CONSTANT_COLOR:
       return PIPE_BLENDFACTOR_INV_CONST_COLOR;
    case GL_ONE_MINUS_CONSTANT_ALPHA:
@@ -98,7 +101,7 @@ gl_blend_to_sp(GLenum blend)
       return PIPE_BLENDFACTOR_INV_SRC1_ALPHA;
       */
    default:
-      assert("invalid GL token in gl_blend_to_sp()" == NULL);
+      assert("invalid GL token in translate_blend()" == NULL);
       return 0;
    }
 }
@@ -108,7 +111,7 @@ gl_blend_to_sp(GLenum blend)
  * Convert GLenum logicop tokens to pipe tokens.
  */
 static GLuint
-gl_logicop_to_sp(GLenum logicop)
+translate_logicop(GLenum logicop)
 {
    switch (logicop) {
    case GL_CLEAR:
@@ -144,7 +147,7 @@ gl_logicop_to_sp(GLenum logicop)
    case GL_SET:
       return PIPE_LOGICOP_SET;
    default:
-      assert("invalid GL token in gl_logicop_to_sp()" == NULL);
+      assert("invalid GL token in translate_logicop()" == NULL);
       return 0;
    }
 }
@@ -153,66 +156,77 @@ gl_logicop_to_sp(GLenum logicop)
 static void 
 update_blend( struct st_context *st )
 {
-   struct pipe_blend_state blend;
+   struct pipe_blend_state *blend = &st->state.blend;
 
-   memset(&blend, 0, sizeof(blend));
+   memset(blend, 0, sizeof(*blend));
 
    if (st->ctx->Color.ColorLogicOpEnabled ||
        (st->ctx->Color.BlendEnabled &&
         st->ctx->Color.BlendEquationRGB == GL_LOGIC_OP)) {
       /* logicop enabled */
-      blend.logicop_enable = 1;
-      blend.logicop_func = gl_logicop_to_sp(st->ctx->Color.LogicOp);
+      blend->logicop_enable = 1;
+      blend->logicop_func = translate_logicop(st->ctx->Color.LogicOp);
    }
    else if (st->ctx->Color.BlendEnabled) {
       /* blending enabled */
-      blend.blend_enable = 1;
+      blend->blend_enable = 1;
 
-      blend.rgb_func = gl_blend_to_sp(st->ctx->Color.BlendEquationRGB);
+      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;
+         blend->rgb_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
       }
       else {
-         blend.rgb_src_factor = gl_blend_to_sp(st->ctx->Color.BlendSrcRGB);
-         blend.rgb_dst_factor = gl_blend_to_sp(st->ctx->Color.BlendDstRGB);
+         blend->rgb_src_factor = translate_blend(st->ctx->Color.BlendSrcRGB);
+         blend->rgb_dst_factor = translate_blend(st->ctx->Color.BlendDstRGB);
       }
 
-      blend.alpha_func = gl_blend_to_sp(st->ctx->Color.BlendEquationA);
+      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;
+         blend->alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
       }
       else {
-         blend.alpha_src_factor = gl_blend_to_sp(st->ctx->Color.BlendSrcA);
-         blend.alpha_dst_factor = gl_blend_to_sp(st->ctx->Color.BlendDstA);
+         blend->alpha_src_factor = translate_blend(st->ctx->Color.BlendSrcA);
+         blend->alpha_dst_factor = translate_blend(st->ctx->Color.BlendDstA);
       }
    }
    else {
       /* no blending / logicop */
    }
 
-   if (memcmp(&blend, &st->state.blend, sizeof(blend)) != 0) {
-      /* state has changed */
-      st->state.blend = blend;  /* struct copy */
-      st->pipe->set_blend_state(st->pipe, &blend); /* set new state */
+   /* Colormask - maybe reverse these bits? */
+   if (st->ctx->Color.ColorMask[0][0])
+      blend->colormask |= PIPE_MASK_R;
+   if (st->ctx->Color.ColorMask[0][1])
+      blend->colormask |= PIPE_MASK_G;
+   if (st->ctx->Color.ColorMask[0][2])
+      blend->colormask |= PIPE_MASK_B;
+   if (st->ctx->Color.ColorMask[0][3])
+      blend->colormask |= PIPE_MASK_A;
+
+   if (st->ctx->Color.DitherFlag)
+      blend->dither = 1;
+
+   cso_set_blend(st->cso_context, blend);
+
+   {
+      struct pipe_blend_color bc;
+      COPY_4FV(bc.color, st->ctx->Color.BlendColor);
+      cso_set_blend_color(st->cso_context, &bc);
    }
 }
 
 
 const struct st_tracked_state st_update_blend = {
-   .dirty = {
-      .mesa = (_NEW_COLOR),  /* XXX _NEW_BLEND someday? */
-      .st  = 0,
+   "st_update_blend",                                  /* name */
+   {                                                   /* dirty */
+      (_NEW_COLOR),  /* XXX _NEW_BLEND someday? */     /* mesa */
+      0,                                               /* st */
    },
-   .update = update_blend
+   update_blend,                                       /* update */
 };
-
-
-
-
-