| 0,0 → 1,301 |
|---|
| /* |
| * 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." |
| */ |
| struct gl_renderbuffer *rb0 = ctx->DrawBuffer->_ColorDrawBuffers[0]; |
| GLenum rb_zero_type = |
| rb0 ? _mesa_get_format_datatype(rb0->Format) : GL_UNSIGNED_NORMALIZED; |
| |
| if (rb_zero_type != GL_INT && rb_zero_type != GL_UNSIGNED_INT) { |
| /* _NEW_MULTISAMPLE */ |
| if (ctx->Multisample._Enabled) { |
| 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]; |
| GLenum rb_type = |
| rb ? _mesa_get_format_datatype(rb->Format) : GL_UNSIGNED_NORMALIZED; |
| |
| /* 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 = rb_type == GL_INT || rb_type == GL_UNSIGNED_INT; |
| |
| /* _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) { |
| 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 && |
| ctx->Multisample._Enabled && |
| 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_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]; |
| |
| /* BRW_NEW_FRAGMENT_PROGRAM | _NEW_BUFFERS | _NEW_COLOR */ |
| if (brw_color_buffer_write_enabled(brw)) |
| dw1 |= GEN8_PS_BLEND_HAS_WRITEABLE_RT; |
| |
| /* _NEW_COLOR */ |
| if (ctx->Color.AlphaEnabled) |
| dw1 |= GEN8_PS_BLEND_ALPHA_TEST_ENABLE; |
| |
| /* _NEW_MULTISAMPLE */ |
| if (ctx->Multisample._Enabled && 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." |
| */ |
| GLenum rb_type = |
| rb ? _mesa_get_format_datatype(rb->Format) : GL_UNSIGNED_NORMALIZED; |
| |
| if (rb && rb_type != GL_INT && rb_type != GL_UNSIGNED_INT && |
| (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_CONTEXT | |
| BRW_NEW_FRAGMENT_PROGRAM, |
| }, |
| .emit = gen8_upload_ps_blend |
| }; |