[Mesa-dev] [PATCH v02 30/37] i965: Port gen6+ blend state code to genxml.
Kenneth Graunke
kenneth at whitecape.org
Wed Apr 26 18:37:27 UTC 2017
On Monday, April 24, 2017 3:19:25 PM PDT Rafael Antognolli wrote:
> Upload blend states using GENX(BLEND_STATE_ENTRY_pack), generated from
> genxml.
>
> Signed-off-by: Rafael Antognolli <rafael.antognolli at intel.com>
> ---
> src/mesa/drivers/dri/i965/Makefile.sources | 1 +-
> src/mesa/drivers/dri/i965/brw_state.h | 3 +-
> src/mesa/drivers/dri/i965/gen6_cc.c | 216 +------------
> src/mesa/drivers/dri/i965/gen8_blend_state.c | 298 +-----------------
> src/mesa/drivers/dri/i965/genX_state_upload.c | 336 ++++++++++++++++++-
> 5 files changed, 332 insertions(+), 522 deletions(-)
> delete mode 100644 src/mesa/drivers/dri/i965/gen8_blend_state.c
>
> diff --git a/src/mesa/drivers/dri/i965/Makefile.sources b/src/mesa/drivers/dri/i965/Makefile.sources
> index 3f0c66a..0c67170 100644
> --- a/src/mesa/drivers/dri/i965/Makefile.sources
> +++ b/src/mesa/drivers/dri/i965/Makefile.sources
> @@ -99,7 +99,6 @@ i965_FILES = \
> gen7_te_state.c \
> gen7_urb.c \
> gen7_wm_surface_state.c \
> - gen8_blend_state.c \
> gen8_depth_state.c \
> gen8_draw_upload.c \
> gen8_multisample_state.c \
> diff --git a/src/mesa/drivers/dri/i965/brw_state.h b/src/mesa/drivers/dri/i965/brw_state.h
> index b6e8abc..cf043a0 100644
> --- a/src/mesa/drivers/dri/i965/brw_state.h
> +++ b/src/mesa/drivers/dri/i965/brw_state.h
> @@ -108,7 +108,6 @@ extern const struct brw_tracked_state brw_index_buffer;
> extern const struct brw_tracked_state brw_cs_state;
> extern const struct brw_tracked_state gen7_cs_push_constants;
> extern const struct brw_tracked_state gen6_binding_table_pointers;
> -extern const struct brw_tracked_state gen6_blend_state;
> extern const struct brw_tracked_state gen6_color_calc_state;
> extern const struct brw_tracked_state gen6_gs_push_constants;
> extern const struct brw_tracked_state gen6_gs_binding_table;
> @@ -130,11 +129,9 @@ extern const struct brw_tracked_state gen7_te_state;
> extern const struct brw_tracked_state gen7_tes_push_constants;
> extern const struct brw_tracked_state gen7_urb;
> extern const struct brw_tracked_state haswell_cut_index;
> -extern const struct brw_tracked_state gen8_blend_state;
> extern const struct brw_tracked_state gen8_index_buffer;
> extern const struct brw_tracked_state gen8_multisample_state;
> extern const struct brw_tracked_state gen8_pma_fix;
> -extern const struct brw_tracked_state gen8_ps_blend;
> extern const struct brw_tracked_state gen8_vertices;
> extern const struct brw_tracked_state gen8_vf_topology;
> extern const struct brw_tracked_state brw_cs_work_groups_surface;
> diff --git a/src/mesa/drivers/dri/i965/gen6_cc.c b/src/mesa/drivers/dri/i965/gen6_cc.c
> index 0e0d05e..688362f 100644
> --- a/src/mesa/drivers/dri/i965/gen6_cc.c
> +++ b/src/mesa/drivers/dri/i965/gen6_cc.c
> @@ -36,222 +36,6 @@
> #include "main/stencil.h"
>
> static void
> -gen6_upload_blend_state(struct brw_context *brw)
> -{
> - bool is_buffer_zero_integer_format = false;
> - struct gl_context *ctx = &brw->ctx;
> - struct gen6_blend_state *blend;
> - int b;
> - int nr_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;
> - int size;
> -
> - /* 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.
> - */
> - if (nr_draw_buffers == 0)
> - nr_draw_buffers = 1;
> -
> - size = sizeof(*blend) * nr_draw_buffers;
> - blend = brw_state_batch(brw, size, 64, &brw->cc.blend_state_offset);
> -
> - memset(blend, 0, size);
> -
> - for (b = 0; b < nr_draw_buffers; b++) {
> - /* _NEW_BUFFERS */
> - struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[b];
> - GLenum rb_type;
> - bool integer;
> -
> - if (rb)
> - rb_type = _mesa_get_format_datatype(rb->Format);
> - else
> - rb_type = 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."
> - */
> - integer = (rb_type == GL_INT || rb_type == GL_UNSIGNED_INT);
> -
> - if(b == 0 && integer)
> - is_buffer_zero_integer_format = true;
> -
> - /* _NEW_COLOR */
> - if (ctx->Color.ColorLogicOpEnabled) {
> - /* Floating point RTs should have no effect from LogicOp,
> - * except for disabling of blending, but other types should.
> - *
> - * However, from the Sandy Bridge PRM, Vol 2 Par 1, Section 8.1.11,
> - * "Logic Ops",
> - *
> - * "Logic Ops are only supported on *_UNORM surfaces (excluding
> - * _SRGB variants), otherwise Logic Ops must be DISABLED."
> - */
> - WARN_ONCE(ctx->Color.LogicOp != GL_COPY &&
> - rb_type != GL_UNSIGNED_NORMALIZED &&
> - rb_type != GL_FLOAT, "Ignoring %s logic op on %s "
> - "renderbuffer\n",
> - _mesa_enum_to_string(ctx->Color.LogicOp),
> - _mesa_enum_to_string(rb_type));
> - if (rb_type == GL_UNSIGNED_NORMALIZED) {
> - blend[b].blend1.logic_op_enable = 1;
> - blend[b].blend1.logic_op_func =
> - intel_translate_logic_op(ctx->Color.LogicOp);
> - }
> - } else if (ctx->Color.BlendEnabled & (1 << b) && !integer &&
> - !ctx->Color._AdvancedBlendMode) {
> - GLenum eqRGB = ctx->Color.Blend[b].EquationRGB;
> - GLenum eqA = ctx->Color.Blend[b].EquationA;
> - GLenum srcRGB = ctx->Color.Blend[b].SrcRGB;
> - GLenum dstRGB = ctx->Color.Blend[b].DstRGB;
> - GLenum srcA = ctx->Color.Blend[b].SrcA;
> - GLenum dstA = ctx->Color.Blend[b].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[b].blend0.dest_blend_factor = brw_translate_blend_factor(dstRGB);
> - blend[b].blend0.source_blend_factor = brw_translate_blend_factor(srcRGB);
> - blend[b].blend0.blend_func = brw_translate_blend_equation(eqRGB);
> -
> - blend[b].blend0.ia_dest_blend_factor = brw_translate_blend_factor(dstA);
> - blend[b].blend0.ia_source_blend_factor = brw_translate_blend_factor(srcA);
> - blend[b].blend0.ia_blend_func = brw_translate_blend_equation(eqA);
> -
> - blend[b].blend0.blend_enable = 1;
> - blend[b].blend0.ia_blend_enable = (srcA != srcRGB ||
> - dstA != dstRGB ||
> - eqA != eqRGB);
> - }
> -
> - /* 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[b].blend1.pre_blend_clamp_enable = 1;
> - blend[b].blend1.post_blend_clamp_enable = 1;
> - blend[b].blend1.clamp_range = BRW_RENDERTARGET_CLAMPRANGE_FORMAT;
> -
> - /* _NEW_COLOR */
> - if (ctx->Color.AlphaEnabled && !integer) {
> - blend[b].blend1.alpha_test_enable = 1;
> - blend[b].blend1.alpha_test_func =
> - intel_translate_compare_func(ctx->Color.AlphaFunc);
> -
> - }
> -
> - /* _NEW_COLOR */
> - if (ctx->Color.DitherFlag && !integer) {
> - blend[b].blend1.dither_enable = 1;
> - blend[b].blend1.y_dither_offset = 0;
> - blend[b].blend1.x_dither_offset = 0;
> - }
> -
> - blend[b].blend1.write_disable_r = !ctx->Color.ColorMask[b][0];
> - blend[b].blend1.write_disable_g = !ctx->Color.ColorMask[b][1];
> - blend[b].blend1.write_disable_b = !ctx->Color.ColorMask[b][2];
> - blend[b].blend1.write_disable_a = !ctx->Color.ColorMask[b][3];
> -
> - /* 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(!is_buffer_zero_integer_format) {
> - /* _NEW_MULTISAMPLE */
> - blend[b].blend1.alpha_to_coverage =
> - _mesa_is_multisample_enabled(ctx) && ctx->Multisample.SampleAlphaToCoverage;
> -
> - /* From SandyBridge PRM, volume 2 Part 1, section 8.2.3, BLEND_STATE:
> - * DWord 1, Bit 30 (AlphaToOne Enable):
> - * "If Dual Source Blending is enabled, this bit must be disabled"
> - */
> - WARN_ONCE(ctx->Color.Blend[b]._UsesDualSrc &&
> - _mesa_is_multisample_enabled(ctx) &&
> - ctx->Multisample.SampleAlphaToOne,
> - "HW workaround: disabling alpha to one with dual src "
> - "blending\n");
> - if (ctx->Color.Blend[b]._UsesDualSrc)
> - blend[b].blend1.alpha_to_one = false;
> - else
> - blend[b].blend1.alpha_to_one =
> - _mesa_is_multisample_enabled(ctx) && ctx->Multisample.SampleAlphaToOne;
> -
> - blend[b].blend1.alpha_to_coverage_dither = (brw->gen >= 7);
> - }
> - else {
> - blend[b].blend1.alpha_to_coverage = false;
> - blend[b].blend1.alpha_to_one = false;
> - }
> - }
> -
> - /* Point the GPU at the new indirect state. */
> - if (brw->gen == 6) {
> - BEGIN_BATCH(4);
> - OUT_BATCH(_3DSTATE_CC_STATE_POINTERS << 16 | (4 - 2));
> - OUT_BATCH(brw->cc.blend_state_offset | 1);
> - OUT_BATCH(0);
> - OUT_BATCH(0);
> - ADVANCE_BATCH();
> - } else {
> - 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 gen6_blend_state = {
> - .dirty = {
> - .mesa = _NEW_BUFFERS |
> - _NEW_COLOR |
> - _NEW_MULTISAMPLE,
> - .brw = BRW_NEW_BATCH |
> - BRW_NEW_BLORP |
> - BRW_NEW_STATE_BASE_ADDRESS,
> - },
> - .emit = gen6_upload_blend_state,
> -};
> -
> -static void
> gen6_upload_color_calc_state(struct brw_context *brw)
> {
> struct gl_context *ctx = &brw->ctx;
> diff --git a/src/mesa/drivers/dri/i965/gen8_blend_state.c b/src/mesa/drivers/dri/i965/gen8_blend_state.c
> deleted file mode 100644
> index 1fa8ba2..0000000
> --- a/src/mesa/drivers/dri/i965/gen8_blend_state.c
> +++ /dev/null
> @@ -1,298 +0,0 @@
> -/*
> - * 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, 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
> -};
> diff --git a/src/mesa/drivers/dri/i965/genX_state_upload.c b/src/mesa/drivers/dri/i965/genX_state_upload.c
> index d2a936b..1bdcea5 100644
> --- a/src/mesa/drivers/dri/i965/genX_state_upload.c
> +++ b/src/mesa/drivers/dri/i965/genX_state_upload.c
> @@ -38,8 +38,10 @@
> #include "intel_buffer_objects.h"
> #include "intel_fbo.h"
>
> +#include "main/enums.h"
> #include "main/fbobject.h"
> #include "main/framebuffer.h"
> +#include "main/glformats.h"
> #include "main/stencil.h"
> #include "main/transformfeedback.h"
> #include "main/viewport.h"
> @@ -1414,6 +1416,241 @@ static const struct brw_tracked_state genX(gs_state) = {
> .emit = genX(upload_gs_state),
> };
>
> +/* ---------------------------------------------------------------------- */
> +
> +#define blend_factor(x) brw_translate_blend_factor(x)
> +#define blend_eqn(x) brw_translate_blend_equation(x)
> +
> +static void
> +genX(upload_blend_state)(struct brw_context *brw)
> +{
> + struct gl_context *ctx = &brw->ctx;
> + int size;
> +
> + /* 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;
> +
> + size = GENX(BLEND_STATE_ENTRY_length) * 4 * nr_draw_buffers;
> +#if GEN_GEN >= 8
> + size += GENX(BLEND_STATE_length) * 4;
> +#endif
> +
> + uint32_t *blend_map;
> + blend_map = brw_state_batch(brw, size, 64, &brw->cc.blend_state_offset);
> + memset(blend_map, 0, size);
Do we need this memset? It probably made sense when we were filling in
bits at random, but genxml should already pack everything with zeroes.
> +
> +#if GEN_GEN >= 8
> + struct GENX(BLEND_STATE) blend = { 0 };
> + {
> +#else
> + for (int i = 0; i < nr_draw_buffers; i++) {
> + struct GENX(BLEND_STATE_ENTRY) entry = { 0 };
> +#define blend entry
> +#endif
I must say, this might be the weirdest looping I've ever seen in code.
But, I'm not really complaining...it's a pretty reasonable solution to
a strange problem...
> + /* 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.AlphaToCoverageEnable = true;
> + blend.AlphaToCoverageDitherEnable = true;
According to commit bc53e14d98de11593788d302c0bb198e3a2097a4, Alpha To
Coverage Dither Enable needs to be false on Sandybridge. So this needs
to remain:
blend.AlphaToCoverageDitherEnable = GEN_GEN >= 7;
> + }
> + if (ctx->Multisample.SampleAlphaToOne)
> + blend.AlphaToOneEnable = true;
> + }
> +
> + /* _NEW_COLOR */
> + if (ctx->Color.AlphaEnabled) {
> + blend.AlphaTestEnable = true;
> + blend.AlphaTestFunction =
> + intel_translate_compare_func(ctx->Color.AlphaFunc);
> + }
> +
> + if (ctx->Color.DitherFlag) {
> + blend.ColorDitherEnable = true;
> + }
> + }
> +
> +#if GEN_GEN >= 8
> + for (int i = 0; i < nr_draw_buffers; i++) {
> + struct GENX(BLEND_STATE_ENTRY) entry = { 0 };
> +#else
> + {
> +#endif
> +
> + /* _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);
> +
> +#if GEN_GEN < 8
> + GLenum rb_type;
> + /* bool is_buffer_zero_integer_format = false; */
> +
> + if (rb)
> + rb_type = _mesa_get_format_datatype(rb->Format);
> + else
> + rb_type = GL_UNSIGNED_NORMALIZED;
> +
> + /* if(i == 0 && integer) */
> + /* is_buffer_zero_integer_format = true; */
> +#endif
Let's delete the above block and add...
> +
> + /* _NEW_COLOR */
> + if (ctx->Color.ColorLogicOpEnabled) {
> +#if GEN_GEN < 8
GLenum rb_type = rb ? _mesa_get_format_datatype(rb->Format)
: GL_UNSIGNED_NORMALIZED;
...which is a bit more succinct and drops an extra #if block.
> + WARN_ONCE(ctx->Color.LogicOp != GL_COPY &&
> + rb_type != GL_UNSIGNED_NORMALIZED &&
> + rb_type != GL_FLOAT, "Ignoring %s logic op on %s "
> + "renderbuffer\n",
> + _mesa_enum_to_string(ctx->Color.LogicOp),
> + _mesa_enum_to_string(rb_type));
> + if (rb_type == GL_UNSIGNED_NORMALIZED) {
> +#endif
Let's drop the #if/#endif and do:
if (GEN_GEN >= 8 || rb_type == GL_UNSIGNED_NORMALIZED) {
(the compiler will optimize away the checks on Gen < 8.)
> + entry.LogicOpEnable = true;
> + entry.LogicOpFunction =
> + intel_translate_logic_op(ctx->Color.LogicOp);
> +#if GEN_GEN < 8
> + }
> +#endif
> + } 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);
> + }
> +
> + entry.ColorBufferBlendEnable = true;
> + entry.DestinationBlendFactor = blend_factor(dstRGB);
> + entry.SourceBlendFactor = blend_factor(srcRGB);
> + entry.DestinationAlphaBlendFactor = blend_factor(dstA);
> + entry.SourceAlphaBlendFactor = blend_factor(srcA);
> + entry.ColorBlendFunction = blend_eqn(eqRGB);
> + entry.AlphaBlendFunction = blend_eqn(eqA);
> +
> + if (srcA != srcRGB || dstA != dstRGB || eqA != eqRGB)
> + blend.IndependentAlphaBlendEnable = true;
> + }
> +
> + /* 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.
> + */
> + entry.PreBlendColorClampEnable = true;
> + entry.PostBlendColorClampEnable = true;
> + entry.ColorClampRange = COLORCLAMP_RTFORMAT;
> +
> + if (!ctx->Color.ColorMask[i][0])
> + entry.WriteDisableRed = true;
> + if (!ctx->Color.ColorMask[i][1])
> + entry.WriteDisableGreen = true;
> + if (!ctx->Color.ColorMask[i][2])
> + entry.WriteDisableBlue = true;
> + if (!ctx->Color.ColorMask[i][3])
> + entry.WriteDisableAlpha = true;
More succinctly,
entry.WriteDisableRed = !ctx->Color.ColorMask[i][0];
entry.WriteDisableGreen = !ctx->Color.ColorMask[i][1];
entry.WriteDisableBlue = !ctx->Color.ColorMask[i][2];
entry.WriteDisableAlpha = !ctx->Color.ColorMask[i][3];
Otherwise this looks good to me :) I made several passes through this
code, comparing from a Gen6 perspective, and a Gen8 perspective.
> +
> + /* 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.AlphaToOneEnable = false;
> +#if GEN_GEN >= 8
> + GENX(BLEND_STATE_ENTRY_pack)(NULL, &blend_map[1 + i * 2], &entry);
> +#else
> + GENX(BLEND_STATE_ENTRY_pack)(NULL, &blend_map[i * 2], &entry);
> +#endif
> + }
> + }
> +
> +#if GEN_GEN >= 8
> + GENX(BLEND_STATE_pack)(NULL, blend_map, &blend);
> +#endif
> +
> +#if GEN_GEN < 7
> + brw_batch_emit(brw, GENX(3DSTATE_CC_STATE_POINTERS), ptr) {
> + ptr.PointertoBLEND_STATE = brw->cc.blend_state_offset;
> + ptr.BLEND_STATEChange = true;
> + }
> +#else
> + brw_batch_emit(brw, GENX(3DSTATE_BLEND_STATE_POINTERS), ptr) {
> + ptr.BlendStatePointer = brw->cc.blend_state_offset;
> +#if GEN_GEN >= 8
> + ptr.BlendStatePointerValid = true;
> +#endif
> + }
> +#endif
> +}
> +
> +static const struct brw_tracked_state genX(blend_state) = {
> + .dirty = {
> + .mesa = _NEW_BUFFERS |
> + _NEW_COLOR |
> + _NEW_MULTISAMPLE,
> + .brw = BRW_NEW_BATCH |
> + BRW_NEW_BLORP |
> + BRW_NEW_STATE_BASE_ADDRESS,
> + },
> + .emit = genX(upload_blend_state),
> +};
> +
> #endif
>
> /* ---------------------------------------------------------------------- */
> @@ -2294,6 +2531,97 @@ const struct brw_tracked_state genX(ps_extra) = {
> },
> .emit = genX(upload_ps_extra),
> };
> +
> +/* ---------------------------------------------------------------------- */
> +
> +static void
> +genX(upload_ps_blend)(struct brw_context *brw)
> +{
> + struct gl_context *ctx = &brw->ctx;
> +
> + /* _NEW_BUFFERS */
> + struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
> + const bool buffer0_is_integer = ctx->DrawBuffer->_IntegerBuffers & 0x1;
> +
> + /* _NEW_COLOR */
> + struct gl_colorbuffer_attrib *color = &ctx->Color;
> +
> + brw_batch_emit(brw, GENX(3DSTATE_PS_BLEND), pb) {
> + /* BRW_NEW_FRAGMENT_PROGRAM | _NEW_BUFFERS | _NEW_COLOR */
> + pb.HasWriteableRT = brw_color_buffer_write_enabled(brw);
> +
> + if (!buffer0_is_integer) {
> + /* _NEW_MULTISAMPLE */
> + pb.AlphaToCoverageEnable =
> + _mesa_is_multisample_enabled(ctx) &&
> + ctx->Multisample.SampleAlphaToCoverage;
> +
> + pb.AlphaTestEnable = color->AlphaEnabled;
> + }
> +
> + /* 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 && (color->BlendEnabled & 1)) {
> + GLenum eqRGB = color->Blend[0].EquationRGB;
> + GLenum eqA = color->Blend[0].EquationA;
> + GLenum srcRGB = color->Blend[0].SrcRGB;
> + GLenum dstRGB = color->Blend[0].DstRGB;
> + GLenum srcA = color->Blend[0].SrcA;
> + GLenum dstA = 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);
> + }
> +
> + pb.ColorBufferBlendEnable = true;
> + pb.SourceAlphaBlendFactor = brw_translate_blend_factor(srcA);
> + pb.DestinationAlphaBlendFactor = brw_translate_blend_factor(dstA);
> + pb.SourceBlendFactor = brw_translate_blend_factor(srcRGB);
> + pb.DestinationBlendFactor = brw_translate_blend_factor(dstRGB);
> +
> + pb.IndependentAlphaBlendEnable =
> + srcA != srcRGB || dstA != dstRGB || eqA != eqRGB;
> + }
> + }
> +}
> +
> +static const struct brw_tracked_state genX(ps_blend) = {
> + .dirty = {
> + .mesa = _NEW_BUFFERS |
> + _NEW_COLOR |
> + _NEW_MULTISAMPLE,
> + .brw = BRW_NEW_BLORP |
> + BRW_NEW_CONTEXT |
> + BRW_NEW_FRAGMENT_PROGRAM,
> + },
> + .emit = genX(upload_ps_blend)
> +};
> #endif
>
> /* ---------------------------------------------------------------------- */
> @@ -2370,7 +2698,7 @@ genX(init_atoms)(struct brw_context *brw)
> &gen6_viewport_state, /* must do after *_vp stages */
>
> &gen6_urb,
> - &gen6_blend_state, /* must do before cc unit */
> + &genX(blend_state), /* must do before cc unit */
> &gen6_color_calc_state, /* must do before cc unit */
> &gen6_depth_stencil_state, /* must do before cc unit */
>
> @@ -2435,7 +2763,7 @@ genX(init_atoms)(struct brw_context *brw)
> &gen7_l3_state,
> &gen7_push_constant_space,
> &gen7_urb,
> - &gen6_blend_state, /* must do before cc unit */
> + &genX(blend_state), /* must do before cc unit */
> &gen6_color_calc_state, /* must do before cc unit */
> &genX(depth_stencil_state), /* must do before cc unit */
>
> @@ -2523,7 +2851,7 @@ genX(init_atoms)(struct brw_context *brw)
> &gen7_l3_state,
> &gen7_push_constant_space,
> &gen7_urb,
> - &gen8_blend_state,
> + &genX(blend_state),
> &gen6_color_calc_state,
>
> &brw_vs_image_surfaces, /* Before vs push/pull constants and binding table */
> @@ -2582,7 +2910,7 @@ genX(init_atoms)(struct brw_context *brw)
> &genX(raster_state),
> &genX(sbe_state),
> &genX(sf_state),
> - &gen8_ps_blend,
> + &genX(ps_blend),
> &genX(ps_extra),
> &genX(ps_state),
> &genX(depth_stencil_state),
>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 833 bytes
Desc: This is a digitally signed message part.
URL: <https://lists.freedesktop.org/archives/mesa-dev/attachments/20170426/685146d6/attachment-0001.sig>
More information about the mesa-dev
mailing list