X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_atom_blend.c;h=a3ad037125b1b225bb945e843e410dbf91951bdf;hb=0719a5f646b26d7fe73a8e0bbc9cae081e8617d2;hp=35c09c3e08fa1b36fbf3012f164908eb1410e7f3;hpb=58a82ee57f1e1e67387dd860ac253223db250789;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..a3ad037125b 100644 --- a/src/mesa/state_tracker/st_atom_blend.c +++ b/src/mesa/state_tracker/st_atom_blend.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -18,7 +18,7 @@ * 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 NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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. @@ -27,7 +27,7 @@ /* * Authors: - * Keith Whitwell + * Keith Whitwell * Brian Paul */ @@ -39,6 +39,9 @@ #include "pipe/p_defines.h" #include "cso_cache/cso_context.h" +#include "framebuffer.h" +#include "main/blend.h" +#include "main/glformats.h" #include "main/macros.h" /** @@ -78,10 +81,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,137 +99,202 @@ 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; } } +/** + * Figure out if colormasks are different per rt. + */ +static GLboolean +colormask_per_rt(const struct gl_context *ctx, unsigned num_cb) +{ + GLbitfield full_mask = _mesa_replicate_colormask(0xf, num_cb); + GLbitfield repl_mask0 = + _mesa_replicate_colormask(GET_COLORMASK(ctx->Color.ColorMask, 0), + num_cb); + + return (ctx->Color.ColorMask & full_mask) != repl_mask0; +} /** - * Convert GLenum logicop tokens to pipe tokens. + * Figure out if blend enables/state are different per rt. */ -static GLuint -translate_logicop(GLenum logicop) +static GLboolean +blend_per_rt(const struct st_context *st, unsigned num_cb) { - switch (logicop) { - case GL_CLEAR: - return PIPE_LOGICOP_CLEAR; - case GL_NOR: - return PIPE_LOGICOP_NOR; - case GL_AND_INVERTED: - return PIPE_LOGICOP_AND_INVERTED; - case GL_COPY_INVERTED: - return PIPE_LOGICOP_COPY_INVERTED; - case GL_AND_REVERSE: - return PIPE_LOGICOP_AND_REVERSE; - case GL_INVERT: - return PIPE_LOGICOP_INVERT; - case GL_XOR: - return PIPE_LOGICOP_XOR; - case GL_NAND: - return PIPE_LOGICOP_NAND; - case GL_AND: - return PIPE_LOGICOP_AND; - case GL_EQUIV: - return PIPE_LOGICOP_EQUIV; - case GL_NOOP: - return PIPE_LOGICOP_NOOP; - case GL_OR_INVERTED: - return PIPE_LOGICOP_OR_INVERTED; - case GL_COPY: - return PIPE_LOGICOP_COPY; - case GL_OR_REVERSE: - return PIPE_LOGICOP_OR_REVERSE; - case GL_OR: - return PIPE_LOGICOP_OR; - case GL_SET: - return PIPE_LOGICOP_SET; - default: - assert("invalid GL token in translate_logicop()" == NULL); - return 0; + const struct gl_context *ctx = st->ctx; + GLbitfield cb_mask = u_bit_consecutive(0, num_cb); + GLbitfield blend_enabled = ctx->Color.BlendEnabled & cb_mask; + + if (blend_enabled && blend_enabled != cb_mask) { + /* 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; + } + if (ctx->DrawBuffer->_IntegerBuffers && + (ctx->DrawBuffer->_IntegerBuffers != cb_mask)) { + /* If there is a mix of integer/non-integer buffers then blending + * must be handled on a per buffer basis. */ + return GL_TRUE; } + + if (st->needs_rgb_dst_alpha_override && ctx->DrawBuffer->_RGBBuffers) { + /* Overriding requires independent blend functions (not just enables), + * require drivers exposing PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND to + * also expose PIPE_CAP_INDEP_BLEND_FUNC. + */ + assert(st->has_indep_blend_func); + + /* If some of the buffers are RGB, we may need to override blend + * factors that reference destination-alpha to constants. We may + * need different blend factor overrides per buffer (say one uses + * a DST_ALPHA factor and another uses INV_DST_ALPHA), so we flip + * on independent blending. This may not be required in all cases, + * but burning the CPU to figure it out is probably not worthwhile. + */ + return GL_TRUE; + } + + return GL_FALSE; } +/** + * Modify blend function to force destination alpha to 1.0 + * + * If \c function specifies a blend function that uses destination alpha, + * replace it with a function that hard-wires destination alpha to 1.0. + * This is useful when emulating a GL RGB format with an RGBA pipe_format. + */ +static enum pipe_blendfactor +fix_xrgb_alpha(enum pipe_blendfactor factor) +{ + switch (factor) { + case PIPE_BLENDFACTOR_DST_ALPHA: + return PIPE_BLENDFACTOR_ONE; -static void -update_blend( struct st_context *st ) + case PIPE_BLENDFACTOR_INV_DST_ALPHA: + case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE: + return PIPE_BLENDFACTOR_ZERO; + default: + return factor; + } +} + +void +st_update_blend( struct st_context *st ) { struct pipe_blend_state *blend = &st->state.blend; + const struct gl_context *ctx = st->ctx; + unsigned num_cb = st->state.fb_num_cb; + 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 (num_cb > 1 && + (blend_per_rt(st, num_cb) || colormask_per_rt(ctx, num_cb))) { + num_state = num_cb; + blend->independent_blend_enable = 1; + } + + for (i = 0; i < num_state; i++) + blend->rt[i].colormask = GET_COLORMASK(ctx->Color.ColorMask, i); + + if (ctx->Color.ColorLogicOpEnabled) { /* logicop enabled */ blend->logicop_enable = 1; - blend->logicop_func = translate_logicop(st->ctx->Color.LogicOp); + blend->logicop_func = ctx->Color._LogicOp; } - else if (st->ctx->Color.BlendEnabled) { + else if (ctx->Color.BlendEnabled && !ctx->Color._AdvancedBlendMode) { /* 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++) { + if (!(ctx->Color.BlendEnabled & (1 << i)) || + (ctx->DrawBuffer->_IntegerBuffers & (1 << i)) || + !blend->rt[i].colormask) + continue; - 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); + if (ctx->Extensions.ARB_draw_buffers_blend) + j = i; + + blend->rt[i].blend_enable = 1; + 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); + } + + const struct gl_renderbuffer *rb = + ctx->DrawBuffer->_ColorDrawBuffers[i]; + + if (st->needs_rgb_dst_alpha_override && rb && + (ctx->DrawBuffer->_RGBBuffers & (1 << i))) { + struct pipe_rt_blend_state *rt = &blend->rt[i]; + rt->rgb_src_factor = fix_xrgb_alpha(rt->rgb_src_factor); + rt->rgb_dst_factor = fix_xrgb_alpha(rt->rgb_dst_factor); + rt->alpha_src_factor = fix_xrgb_alpha(rt->alpha_src_factor); + rt->alpha_dst_factor = fix_xrgb_alpha(rt->alpha_dst_factor); + } } } else { /* no blending / logicop */ } - /* 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; + blend->dither = ctx->Color.DitherFlag; - if (st->ctx->Color.DitherFlag) - blend->dither = 1; + if (_mesa_is_multisample_enabled(ctx) && + !(ctx->DrawBuffer->_IntegerBuffers & 0x1)) { + /* Unlike in gallium/d3d10 these operations are only performed + * if both msaa is enabled and we have a multisample buffer. + */ + blend->alpha_to_coverage = ctx->Multisample.SampleAlphaToCoverage; + blend->alpha_to_one = ctx->Multisample.SampleAlphaToOne; + } 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); - } } +void +st_update_blend_color(struct st_context *st) +{ + struct pipe_blend_color bc; -const struct st_tracked_state st_update_blend = { - "st_update_blend", /* name */ - { /* dirty */ - (_NEW_COLOR), /* XXX _NEW_BLEND someday? */ /* mesa */ - 0, /* st */ - }, - update_blend, /* update */ -}; + COPY_4FV(bc.color, st->ctx->Color.BlendColorUnclamped); + cso_set_blend_color(st->cso_context, &bc); +}