/* * Copyright © 2012 Intel Corporation * * 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 (including the next * paragraph) 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 * THE AUTHORS OR COPYRIGHT HOLDERS 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 "brw_context.h" #include "brw_state.h" #include "brw_defines.h" #include "brw_util.h" #include "brw_wm.h" #include "intel_batchbuffer.h" #include "main/macros.h" #include "main/enums.h" #include "main/glformats.h" #define blend_factor(x) brw_translate_blend_factor(x) #define blend_eqn(x) brw_translate_blend_equation(x) static void gen8_upload_blend_state(struct brw_context *brw) { struct gl_context *ctx = &brw->ctx; /* We need at least one BLEND_STATE written, because we might do * thread dispatch even if _NumColorDrawBuffers is 0 (for example * for computed depth or alpha test), which will do an FB write * with render target 0, which will reference BLEND_STATE[0] for * alpha test enable. */ int nr_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers; if (nr_draw_buffers == 0 && ctx->Color.AlphaEnabled) nr_draw_buffers = 1; int size = 4 + 8 * nr_draw_buffers; uint32_t *blend = brw_state_batch(brw, AUB_TRACE_BLEND_STATE, size, 64, &brw->cc.blend_state_offset); memset(blend, 0, size); /* OpenGL specification 3.3 (page 196), section 4.1.3 says: * "If drawbuffer zero is not NONE and the buffer it references has an * integer format, the SAMPLE_ALPHA_TO_COVERAGE and SAMPLE_ALPHA_TO_ONE * operations are skipped." */ if (!(ctx->DrawBuffer->_IntegerBuffers & 0x1)) { /* _NEW_MULTISAMPLE */ if (_mesa_is_multisample_enabled(ctx)) { if (ctx->Multisample.SampleAlphaToCoverage) { blend[0] |= GEN8_BLEND_ALPHA_TO_COVERAGE_ENABLE; blend[0] |= GEN8_BLEND_ALPHA_TO_COVERAGE_DITHER_ENABLE; } if (ctx->Multisample.SampleAlphaToOne) blend[0] |= GEN8_BLEND_ALPHA_TO_ONE_ENABLE; } /* _NEW_COLOR */ if (ctx->Color.AlphaEnabled) { blend[0] |= GEN8_BLEND_ALPHA_TEST_ENABLE | SET_FIELD(intel_translate_compare_func(ctx->Color.AlphaFunc), GEN8_BLEND_ALPHA_TEST_FUNCTION); } if (ctx->Color.DitherFlag) { blend[0] |= GEN8_BLEND_COLOR_DITHER_ENABLE; } } for (int i = 0; i < nr_draw_buffers; i++) { /* _NEW_BUFFERS */ struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i]; /* Used for implementing the following bit of GL_EXT_texture_integer: * "Per-fragment operations that require floating-point color * components, including multisample alpha operations, alpha test, * blending, and dithering, have no effect when the corresponding * colors are written to an integer color buffer." */ bool integer = ctx->DrawBuffer->_IntegerBuffers & (0x1 << i); /* _NEW_COLOR */ if (ctx->Color.ColorLogicOpEnabled) { blend[1 + 2*i+1] |= GEN8_BLEND_LOGIC_OP_ENABLE | SET_FIELD(intel_translate_logic_op(ctx->Color.LogicOp), GEN8_BLEND_LOGIC_OP_FUNCTION); } else if (ctx->Color.BlendEnabled & (1 << i) && !integer && !ctx->Color._AdvancedBlendMode) { GLenum eqRGB = ctx->Color.Blend[i].EquationRGB; GLenum eqA = ctx->Color.Blend[i].EquationA; GLenum srcRGB = ctx->Color.Blend[i].SrcRGB; GLenum dstRGB = ctx->Color.Blend[i].DstRGB; GLenum srcA = ctx->Color.Blend[i].SrcA; GLenum dstA = ctx->Color.Blend[i].DstA; if (eqRGB == GL_MIN || eqRGB == GL_MAX) srcRGB = dstRGB = GL_ONE; if (eqA == GL_MIN || eqA == GL_MAX) srcA = dstA = GL_ONE; /* Due to hardware limitations, the destination may have information * in an alpha channel even when the format specifies no alpha * channel. In order to avoid getting any incorrect blending due to * that alpha channel, coerce the blend factors to values that will * not read the alpha channel, but will instead use the correct * implicit value for alpha. */ if (rb && !_mesa_base_format_has_channel(rb->_BaseFormat, GL_TEXTURE_ALPHA_TYPE)) { srcRGB = brw_fix_xRGB_alpha(srcRGB); srcA = brw_fix_xRGB_alpha(srcA); dstRGB = brw_fix_xRGB_alpha(dstRGB); dstA = brw_fix_xRGB_alpha(dstA); } blend[1 + 2*i] |= GEN8_BLEND_COLOR_BUFFER_BLEND_ENABLE | SET_FIELD(blend_factor(dstRGB), GEN8_BLEND_DST_BLEND_FACTOR) | SET_FIELD(blend_factor(srcRGB), GEN8_BLEND_SRC_BLEND_FACTOR) | SET_FIELD(blend_factor(dstA), GEN8_BLEND_DST_ALPHA_BLEND_FACTOR) | SET_FIELD(blend_factor(srcA), GEN8_BLEND_SRC_ALPHA_BLEND_FACTOR) | SET_FIELD(blend_eqn(eqRGB), GEN8_BLEND_COLOR_BLEND_FUNCTION) | SET_FIELD(blend_eqn(eqA), GEN8_BLEND_ALPHA_BLEND_FUNCTION); if (srcA != srcRGB || dstA != dstRGB || eqA != eqRGB) blend[0] |= GEN8_BLEND_INDEPENDENT_ALPHA_BLEND_ENABLE; } /* See section 8.1.6 "Pre-Blend Color Clamping" of the * SandyBridge PRM Volume 2 Part 1 for HW requirements. * * We do our ARB_color_buffer_float CLAMP_FRAGMENT_COLOR * clamping in the fragment shader. For its clamping of * blending, the spec says: * * "RESOLVED: For fixed-point color buffers, the inputs and * the result of the blending equation are clamped. For * floating-point color buffers, no clamping occurs." * * So, generally, we want clamping to the render target's range. * And, good news, the hardware tables for both pre- and * post-blend color clamping are either ignored, or any are * allowed, or clamping is required but RT range clamping is a * valid option. */ blend[1 + 2*i+1] |= GEN8_BLEND_PRE_BLEND_COLOR_CLAMP_ENABLE | GEN8_BLEND_POST_BLEND_COLOR_CLAMP_ENABLE | GEN8_BLEND_COLOR_CLAMP_RANGE_RTFORMAT; if (!ctx->Color.ColorMask[i][0]) blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_RED; if (!ctx->Color.ColorMask[i][1]) blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_GREEN; if (!ctx->Color.ColorMask[i][2]) blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_BLUE; if (!ctx->Color.ColorMask[i][3]) blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_ALPHA; /* From the BLEND_STATE docs, DWord 0, Bit 29 (AlphaToOne Enable): * "If Dual Source Blending is enabled, this bit must be disabled." */ WARN_ONCE(ctx->Color.Blend[i]._UsesDualSrc && _mesa_is_multisample_enabled(ctx) && ctx->Multisample.SampleAlphaToOne, "HW workaround: disabling alpha to one with dual src " "blending\n"); if (ctx->Color.Blend[i]._UsesDualSrc) blend[0] &= ~GEN8_BLEND_ALPHA_TO_ONE_ENABLE; } BEGIN_BATCH(2); OUT_BATCH(_3DSTATE_BLEND_STATE_POINTERS << 16 | (2 - 2)); OUT_BATCH(brw->cc.blend_state_offset | 1); ADVANCE_BATCH(); } const struct brw_tracked_state gen8_blend_state = { .dirty = { .mesa = _NEW_BUFFERS | _NEW_COLOR | _NEW_MULTISAMPLE, .brw = BRW_NEW_BATCH | BRW_NEW_BLORP | BRW_NEW_STATE_BASE_ADDRESS, }, .emit = gen8_upload_blend_state, }; static void gen8_upload_ps_blend(struct brw_context *brw) { struct gl_context *ctx = &brw->ctx; uint32_t dw1 = 0; /* _NEW_BUFFERS */ struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0]; const bool buffer0_is_integer = ctx->DrawBuffer->_IntegerBuffers & 0x1; /* BRW_NEW_FRAGMENT_PROGRAM | _NEW_BUFFERS | _NEW_COLOR */ if (brw_color_buffer_write_enabled(brw)) dw1 |= GEN8_PS_BLEND_HAS_WRITEABLE_RT; if(!buffer0_is_integer) { /* _NEW_COLOR */ if (ctx->Color.AlphaEnabled) dw1 |= GEN8_PS_BLEND_ALPHA_TEST_ENABLE; /* _NEW_MULTISAMPLE */ if (_mesa_is_multisample_enabled(ctx) && ctx->Multisample.SampleAlphaToCoverage) dw1 |= GEN8_PS_BLEND_ALPHA_TO_COVERAGE_ENABLE; } /* Used for implementing the following bit of GL_EXT_texture_integer: * "Per-fragment operations that require floating-point color * components, including multisample alpha operations, alpha test, * blending, and dithering, have no effect when the corresponding * colors are written to an integer color buffer." * * The OpenGL specification 3.3 (page 196), section 4.1.3 says: * "If drawbuffer zero is not NONE and the buffer it references has an * integer format, the SAMPLE_ALPHA_TO_COVERAGE and SAMPLE_ALPHA_TO_ONE * operations are skipped." */ if (rb && !buffer0_is_integer && (ctx->Color.BlendEnabled & 1)) { GLenum eqRGB = ctx->Color.Blend[0].EquationRGB; GLenum eqA = ctx->Color.Blend[0].EquationA; GLenum srcRGB = ctx->Color.Blend[0].SrcRGB; GLenum dstRGB = ctx->Color.Blend[0].DstRGB; GLenum srcA = ctx->Color.Blend[0].SrcA; GLenum dstA = ctx->Color.Blend[0].DstA; if (eqRGB == GL_MIN || eqRGB == GL_MAX) srcRGB = dstRGB = GL_ONE; if (eqA == GL_MIN || eqA == GL_MAX) srcA = dstA = GL_ONE; /* Due to hardware limitations, the destination may have information * in an alpha channel even when the format specifies no alpha * channel. In order to avoid getting any incorrect blending due to * that alpha channel, coerce the blend factors to values that will * not read the alpha channel, but will instead use the correct * implicit value for alpha. */ if (!_mesa_base_format_has_channel(rb->_BaseFormat, GL_TEXTURE_ALPHA_TYPE)) { srcRGB = brw_fix_xRGB_alpha(srcRGB); srcA = brw_fix_xRGB_alpha(srcA); dstRGB = brw_fix_xRGB_alpha(dstRGB); dstA = brw_fix_xRGB_alpha(dstA); } dw1 |= GEN8_PS_BLEND_COLOR_BUFFER_BLEND_ENABLE | SET_FIELD(blend_factor(dstRGB), GEN8_PS_BLEND_DST_BLEND_FACTOR) | SET_FIELD(blend_factor(srcRGB), GEN8_PS_BLEND_SRC_BLEND_FACTOR) | SET_FIELD(blend_factor(dstA), GEN8_PS_BLEND_DST_ALPHA_BLEND_FACTOR) | SET_FIELD(blend_factor(srcA), GEN8_PS_BLEND_SRC_ALPHA_BLEND_FACTOR); if (srcA != srcRGB || dstA != dstRGB || eqA != eqRGB) dw1 |= GEN8_PS_BLEND_INDEPENDENT_ALPHA_BLEND_ENABLE; } BEGIN_BATCH(2); OUT_BATCH(_3DSTATE_PS_BLEND << 16 | (2 - 2)); OUT_BATCH(dw1); ADVANCE_BATCH(); } const struct brw_tracked_state gen8_ps_blend = { .dirty = { .mesa = _NEW_BUFFERS | _NEW_COLOR | _NEW_MULTISAMPLE, .brw = BRW_NEW_BLORP | BRW_NEW_CONTEXT | BRW_NEW_FRAGMENT_PROGRAM, }, .emit = gen8_upload_ps_blend };