src/mesa/drivers/dri/i965/gen8_blend_state.c

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "brw_context.h"
  25 #include "brw_state.h"
  26 #include "brw_defines.h"
  27 #include "brw_util.h"
  28 #include "brw_wm.h"
  29 #include "intel_batchbuffer.h"
  30 #include "main/macros.h"
  31 #include "main/enums.h"
  32 #include "main/glformats.h"
  33
  34 #define blend_factor(x) brw_translate_blend_factor(x)
  35 #define blend_eqn(x) brw_translate_blend_equation(x)
  36
  37 static void
  38 gen8_upload_blend_state(struct brw_context *brw)
  39 {
  40    struct gl_context *ctx = &brw->ctx;
  41
  42    /* We need at least one BLEND_STATE written, because we might do
  43     * thread dispatch even if _NumColorDrawBuffers is 0 (for example
  44     * for computed depth or alpha test), which will do an FB write
  45     * with render target 0, which will reference BLEND_STATE[0] for
  46     * alpha test enable.
  47     */
  48    int nr_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;
  49    if (nr_draw_buffers == 0 && ctx->Color.AlphaEnabled)
  50       nr_draw_buffers = 1;
  51
  52    int size = 4 + 8 * nr_draw_buffers;
  53    uint32_t *blend = brw_state_batch(brw, AUB_TRACE_BLEND_STATE,
  54                                      size, 64, &brw->cc.blend_state_offset);
  55    memset(blend, 0, size);
  56
  57    /* OpenGL specification 3.3 (page 196), section 4.1.3 says:
  58     * "If drawbuffer zero is not NONE and the buffer it references has an
  59     * integer format, the SAMPLE_ALPHA_TO_COVERAGE and SAMPLE_ALPHA_TO_ONE
  60     * operations are skipped."
  61     */
  62    if (!(ctx->DrawBuffer->_IntegerBuffers & 0x1)) {
  63       /* _NEW_MULTISAMPLE */
  64       if (_mesa_is_multisample_enabled(ctx)) {
  65          if (ctx->Multisample.SampleAlphaToCoverage) {
  66             blend[0] |= GEN8_BLEND_ALPHA_TO_COVERAGE_ENABLE;
  67             blend[0] |= GEN8_BLEND_ALPHA_TO_COVERAGE_DITHER_ENABLE;
  68          }
  69          if (ctx->Multisample.SampleAlphaToOne)
  70             blend[0] |= GEN8_BLEND_ALPHA_TO_ONE_ENABLE;
  71       }
  72
  73       /* _NEW_COLOR */
  74       if (ctx->Color.AlphaEnabled) {
  75          blend[0] |=
  76             GEN8_BLEND_ALPHA_TEST_ENABLE |
  77             SET_FIELD(intel_translate_compare_func(ctx->Color.AlphaFunc),
  78                       GEN8_BLEND_ALPHA_TEST_FUNCTION);
  79       }
  80
  81       if (ctx->Color.DitherFlag) {
  82          blend[0] |= GEN8_BLEND_COLOR_DITHER_ENABLE;
  83       }
  84    }
  85
  86    for (int i = 0; i < nr_draw_buffers; i++) {
  87       /* _NEW_BUFFERS */
  88       struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i];
  89
  90       /* Used for implementing the following bit of GL_EXT_texture_integer:
  91        * "Per-fragment operations that require floating-point color
  92        *  components, including multisample alpha operations, alpha test,
  93        *  blending, and dithering, have no effect when the corresponding
  94        *  colors are written to an integer color buffer."
  95       */
  96       bool integer = ctx->DrawBuffer->_IntegerBuffers & (0x1 << i);
  97
  98       /* _NEW_COLOR */
  99       if (ctx->Color.ColorLogicOpEnabled) {
 100          blend[1 + 2*i+1] |=
 101             GEN8_BLEND_LOGIC_OP_ENABLE |
 102             SET_FIELD(intel_translate_logic_op(ctx->Color.LogicOp),
 103                       GEN8_BLEND_LOGIC_OP_FUNCTION);
 104       } else if (ctx->Color.BlendEnabled & (1 << i) && !integer &&
 105                  !ctx->Color._AdvancedBlendMode) {
 106          GLenum eqRGB = ctx->Color.Blend[i].EquationRGB;
 107          GLenum eqA = ctx->Color.Blend[i].EquationA;
 108          GLenum srcRGB = ctx->Color.Blend[i].SrcRGB;
 109          GLenum dstRGB = ctx->Color.Blend[i].DstRGB;
 110          GLenum srcA = ctx->Color.Blend[i].SrcA;
 111          GLenum dstA = ctx->Color.Blend[i].DstA;
 112
 113          if (eqRGB == GL_MIN || eqRGB == GL_MAX)
 114             srcRGB = dstRGB = GL_ONE;
 115
 116          if (eqA == GL_MIN || eqA == GL_MAX)
 117             srcA = dstA = GL_ONE;
 118
 119          /* Due to hardware limitations, the destination may have information
 120           * in an alpha channel even when the format specifies no alpha
 121           * channel. In order to avoid getting any incorrect blending due to
 122           * that alpha channel, coerce the blend factors to values that will
 123           * not read the alpha channel, but will instead use the correct
 124           * implicit value for alpha.
 125           */
 126          if (rb && !_mesa_base_format_has_channel(rb->_BaseFormat, GL_TEXTURE_ALPHA_TYPE)) {
 127             srcRGB = brw_fix_xRGB_alpha(srcRGB);
 128             srcA = brw_fix_xRGB_alpha(srcA);
 129             dstRGB = brw_fix_xRGB_alpha(dstRGB);
 130             dstA = brw_fix_xRGB_alpha(dstA);
 131          }
 132
 133          blend[1 + 2*i] |=
 134             GEN8_BLEND_COLOR_BUFFER_BLEND_ENABLE |
 135             SET_FIELD(blend_factor(dstRGB), GEN8_BLEND_DST_BLEND_FACTOR) |
 136             SET_FIELD(blend_factor(srcRGB), GEN8_BLEND_SRC_BLEND_FACTOR) |
 137             SET_FIELD(blend_factor(dstA), GEN8_BLEND_DST_ALPHA_BLEND_FACTOR) |
 138             SET_FIELD(blend_factor(srcA), GEN8_BLEND_SRC_ALPHA_BLEND_FACTOR) |
 139             SET_FIELD(blend_eqn(eqRGB), GEN8_BLEND_COLOR_BLEND_FUNCTION) |
 140             SET_FIELD(blend_eqn(eqA), GEN8_BLEND_ALPHA_BLEND_FUNCTION);
 141
 142          if (srcA != srcRGB || dstA != dstRGB || eqA != eqRGB)
 143             blend[0] |= GEN8_BLEND_INDEPENDENT_ALPHA_BLEND_ENABLE;
 144       }
 145
 146       /* See section 8.1.6 "Pre-Blend Color Clamping" of the
 147        * SandyBridge PRM Volume 2 Part 1 for HW requirements.
 148        *
 149        * We do our ARB_color_buffer_float CLAMP_FRAGMENT_COLOR
 150        * clamping in the fragment shader.  For its clamping of
 151        * blending, the spec says:
 152        *
 153        *     "RESOLVED: For fixed-point color buffers, the inputs and
 154        *      the result of the blending equation are clamped.  For
 155        *      floating-point color buffers, no clamping occurs."
 156        *
 157        * So, generally, we want clamping to the render target's range.
 158        * And, good news, the hardware tables for both pre- and
 159        * post-blend color clamping are either ignored, or any are
 160        * allowed, or clamping is required but RT range clamping is a
 161        * valid option.
 162        */
 163       blend[1 + 2*i+1] |=
 164          GEN8_BLEND_PRE_BLEND_COLOR_CLAMP_ENABLE |
 165          GEN8_BLEND_POST_BLEND_COLOR_CLAMP_ENABLE |
 166          GEN8_BLEND_COLOR_CLAMP_RANGE_RTFORMAT;
 167
 168       if (!ctx->Color.ColorMask[i][0])
 169          blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_RED;
 170       if (!ctx->Color.ColorMask[i][1])
 171          blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_GREEN;
 172       if (!ctx->Color.ColorMask[i][2])
 173          blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_BLUE;
 174       if (!ctx->Color.ColorMask[i][3])
 175          blend[1 + 2*i] |= GEN8_BLEND_WRITE_DISABLE_ALPHA;
 176
 177      /* From the BLEND_STATE docs, DWord 0, Bit 29 (AlphaToOne Enable):
 178       * "If Dual Source Blending is enabled, this bit must be disabled."
 179       */
 180       WARN_ONCE(ctx->Color.Blend[i]._UsesDualSrc &&
 181                 _mesa_is_multisample_enabled(ctx) &&
 182                 ctx->Multisample.SampleAlphaToOne,
 183                 "HW workaround: disabling alpha to one with dual src "
 184                 "blending\n");
 185       if (ctx->Color.Blend[i]._UsesDualSrc)
 186          blend[0] &= ~GEN8_BLEND_ALPHA_TO_ONE_ENABLE;
 187    }
 188
 189    BEGIN_BATCH(2);
 190    OUT_BATCH(_3DSTATE_BLEND_STATE_POINTERS << 16 | (2 - 2));
 191    OUT_BATCH(brw->cc.blend_state_offset | 1);
 192    ADVANCE_BATCH();
 193 }
 194
 195 const struct brw_tracked_state gen8_blend_state = {
 196    .dirty = {
 197       .mesa = _NEW_BUFFERS |
 198               _NEW_COLOR |
 199               _NEW_MULTISAMPLE,
 200       .brw = BRW_NEW_BATCH |
 201              BRW_NEW_BLORP |
 202              BRW_NEW_STATE_BASE_ADDRESS,
 203    },
 204    .emit = gen8_upload_blend_state,
 205 };
 206
 207 static void
 208 gen8_upload_ps_blend(struct brw_context *brw)
 209 {
 210    struct gl_context *ctx = &brw->ctx;
 211    uint32_t dw1 = 0;
 212
 213    /* _NEW_BUFFERS */
 214    struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
 215    const bool buffer0_is_integer = ctx->DrawBuffer->_IntegerBuffers & 0x1;
 216
 217    /* BRW_NEW_FRAGMENT_PROGRAM | _NEW_BUFFERS | _NEW_COLOR */
 218    if (brw_color_buffer_write_enabled(brw))
 219       dw1 |= GEN8_PS_BLEND_HAS_WRITEABLE_RT;
 220
 221    if(!buffer0_is_integer) {
 222       /* _NEW_COLOR */
 223       if (ctx->Color.AlphaEnabled)
 224          dw1 |= GEN8_PS_BLEND_ALPHA_TEST_ENABLE;
 225
 226       /* _NEW_MULTISAMPLE */
 227       if (_mesa_is_multisample_enabled(ctx) &&
 228           ctx->Multisample.SampleAlphaToCoverage)
 229          dw1 |= GEN8_PS_BLEND_ALPHA_TO_COVERAGE_ENABLE;
 230    }
 231
 232    /* Used for implementing the following bit of GL_EXT_texture_integer:
 233     * "Per-fragment operations that require floating-point color
 234     *  components, including multisample alpha operations, alpha test,
 235     *  blending, and dithering, have no effect when the corresponding
 236     *  colors are written to an integer color buffer."
 237     *
 238     * The OpenGL specification 3.3 (page 196), section 4.1.3 says:
 239     * "If drawbuffer zero is not NONE and the buffer it references has an
 240     *  integer format, the SAMPLE_ALPHA_TO_COVERAGE and SAMPLE_ALPHA_TO_ONE
 241     *  operations are skipped."
 242     */
 243    if (rb && !buffer0_is_integer && (ctx->Color.BlendEnabled & 1)) {
 244       GLenum eqRGB = ctx->Color.Blend[0].EquationRGB;
 245       GLenum eqA = ctx->Color.Blend[0].EquationA;
 246       GLenum srcRGB = ctx->Color.Blend[0].SrcRGB;
 247       GLenum dstRGB = ctx->Color.Blend[0].DstRGB;
 248       GLenum srcA = ctx->Color.Blend[0].SrcA;
 249       GLenum dstA = ctx->Color.Blend[0].DstA;
 250
 251       if (eqRGB == GL_MIN || eqRGB == GL_MAX)
 252          srcRGB = dstRGB = GL_ONE;
 253
 254       if (eqA == GL_MIN || eqA == GL_MAX)
 255          srcA = dstA = GL_ONE;
 256
 257       /* Due to hardware limitations, the destination may have information
 258        * in an alpha channel even when the format specifies no alpha
 259        * channel. In order to avoid getting any incorrect blending due to
 260        * that alpha channel, coerce the blend factors to values that will
 261        * not read the alpha channel, but will instead use the correct
 262        * implicit value for alpha.
 263        */
 264       if (!_mesa_base_format_has_channel(rb->_BaseFormat, GL_TEXTURE_ALPHA_TYPE)) {
 265          srcRGB = brw_fix_xRGB_alpha(srcRGB);
 266          srcA = brw_fix_xRGB_alpha(srcA);
 267          dstRGB = brw_fix_xRGB_alpha(dstRGB);
 268          dstA = brw_fix_xRGB_alpha(dstA);
 269       }
 270
 271       dw1 |=
 272          GEN8_PS_BLEND_COLOR_BUFFER_BLEND_ENABLE |
 273          SET_FIELD(blend_factor(dstRGB), GEN8_PS_BLEND_DST_BLEND_FACTOR) |
 274          SET_FIELD(blend_factor(srcRGB), GEN8_PS_BLEND_SRC_BLEND_FACTOR) |
 275          SET_FIELD(blend_factor(dstA), GEN8_PS_BLEND_DST_ALPHA_BLEND_FACTOR) |
 276          SET_FIELD(blend_factor(srcA), GEN8_PS_BLEND_SRC_ALPHA_BLEND_FACTOR);
 277
 278       if (srcA != srcRGB || dstA != dstRGB || eqA != eqRGB)
 279          dw1 |= GEN8_PS_BLEND_INDEPENDENT_ALPHA_BLEND_ENABLE;
 280    }
 281
 282    BEGIN_BATCH(2);
 283    OUT_BATCH(_3DSTATE_PS_BLEND << 16 | (2 - 2));
 284    OUT_BATCH(dw1);
 285    ADVANCE_BATCH();
 286 }
 287
 288 const struct brw_tracked_state gen8_ps_blend = {
 289    .dirty = {
 290       .mesa = _NEW_BUFFERS |
 291               _NEW_COLOR |
 292               _NEW_MULTISAMPLE,
 293       .brw = BRW_NEW_BLORP |
 294              BRW_NEW_CONTEXT |
 295              BRW_NEW_FRAGMENT_PROGRAM,
 296    },
 297    .emit = gen8_upload_ps_blend
 298 };