[Mesa-dev] [PATCH v02 21/37] i965: Port gen6+ 3DSTATE_SF to genxml.
Kenneth Graunke
kenneth at whitecape.org
Wed Apr 26 23:11:50 UTC 2017
On Monday, April 24, 2017 3:19:16 PM PDT Rafael Antognolli wrote:
> Emit sf state on Gen6+ using brw_batch_emit helper, using pack structs
> from genxml.
>
> Signed-off-by: Rafael Antognolli <rafael.antognolli at intel.com>
> ---
> src/mesa/drivers/dri/i965/brw_state.h | 3 +-
> src/mesa/drivers/dri/i965/brw_util.h | 25 +-
> src/mesa/drivers/dri/i965/gen6_sf_state.c | 190 +--------
> src/mesa/drivers/dri/i965/gen7_sf_state.c | 156 +-------
> src/mesa/drivers/dri/i965/gen8_sf_state.c | 73 +---
> src/mesa/drivers/dri/i965/genX_state_upload.c | 428 ++++++++++++++++++-
> 6 files changed, 439 insertions(+), 436 deletions(-)
>
> diff --git a/src/mesa/drivers/dri/i965/brw_state.h b/src/mesa/drivers/dri/i965/brw_state.h
> index 3a10a8a..594757c 100644
> --- a/src/mesa/drivers/dri/i965/brw_state.h
> +++ b/src/mesa/drivers/dri/i965/brw_state.h
> @@ -119,7 +119,6 @@ extern const struct brw_tracked_state gen6_renderbuffer_surfaces;
> extern const struct brw_tracked_state gen6_sampler_state;
> extern const struct brw_tracked_state gen6_scissor_state;
> extern const struct brw_tracked_state gen6_sol_surface;
> -extern const struct brw_tracked_state gen6_sf_state;
> extern const struct brw_tracked_state gen6_sf_vp;
> extern const struct brw_tracked_state gen6_urb;
> extern const struct brw_tracked_state gen6_viewport_state;
> @@ -137,7 +136,6 @@ extern const struct brw_tracked_state gen7_ps_state;
> extern const struct brw_tracked_state gen7_push_constant_space;
> extern const struct brw_tracked_state gen7_sbe_state;
> extern const struct brw_tracked_state gen7_sf_clip_viewport;
> -extern const struct brw_tracked_state gen7_sf_state;
> extern const struct brw_tracked_state gen7_sol_state;
> extern const struct brw_tracked_state gen7_te_state;
> extern const struct brw_tracked_state gen7_tes_push_constants;
> @@ -157,7 +155,6 @@ extern const struct brw_tracked_state gen8_ps_extra;
> extern const struct brw_tracked_state gen8_ps_state;
> extern const struct brw_tracked_state gen8_wm_state;
> extern const struct brw_tracked_state gen8_sbe_state;
> -extern const struct brw_tracked_state gen8_sf_state;
> extern const struct brw_tracked_state gen8_sf_clip_viewport;
> extern const struct brw_tracked_state gen8_vertices;
> extern const struct brw_tracked_state gen8_vf_topology;
> diff --git a/src/mesa/drivers/dri/i965/brw_util.h b/src/mesa/drivers/dri/i965/brw_util.h
> index 3e9a6ee..7395d34 100644
> --- a/src/mesa/drivers/dri/i965/brw_util.h
> +++ b/src/mesa/drivers/dri/i965/brw_util.h
> @@ -40,8 +40,8 @@ extern GLuint brw_translate_blend_factor( GLenum factor );
> extern GLuint brw_translate_blend_equation( GLenum mode );
> extern GLenum brw_fix_xRGB_alpha(GLenum function);
>
> -static inline uint32_t
> -brw_get_line_width(struct brw_context *brw)
> +static inline float
> +brw_get_line_width_float(struct brw_context *brw)
> {
> /* From the OpenGL 4.4 spec:
> *
> @@ -52,14 +52,9 @@ brw_get_line_width(struct brw_context *brw)
> float line_width =
> CLAMP(!_mesa_is_multisample_enabled(&brw->ctx) && !brw->ctx.Line.SmoothFlag
> ? roundf(brw->ctx.Line.Width) : brw->ctx.Line.Width,
> - 0.0f, brw->ctx.Const.MaxLineWidth);
> - uint32_t line_width_u3_7 = U_FIXED(line_width, 7);
> + 0.125f, brw->ctx.Const.MaxLineWidth);
>
> - /* Line width of 0 is not allowed when MSAA enabled */
> - if (_mesa_is_multisample_enabled(&brw->ctx)) {
> - if (line_width_u3_7 == 0)
> - line_width_u3_7 = 1;
> - } else if (brw->ctx.Line.SmoothFlag && line_width < 1.5f) {
> + if (!_mesa_is_multisample_enabled(&brw->ctx) && brw->ctx.Line.SmoothFlag && line_width < 1.5f) {
> /* For 1 pixel line thickness or less, the general
> * anti-aliasing algorithm gives up, and a garbage line is
> * generated. Setting a Line Width of 0.0 specifies the
> @@ -71,10 +66,18 @@ brw_get_line_width(struct brw_context *brw)
> * bspec section 6.3.12.1 Zero-Width (Cosmetic) Line
> * Rasterization.
> */
> - line_width_u3_7 = 0;
> + line_width = 0.0f;
> }
>
> - return line_width_u3_7;
> + return line_width;
> +}
> +
> +static inline uint32_t
> +brw_get_line_width(struct brw_context *brw)
> +{
> + float line_width = brw_get_line_width_float(brw);
> +
> + return U_FIXED(line_width, 7);
> }
>
> #endif
Hey Rafael,
Can we split out the above hunks to a separate patch? If split, the
above line width changes are:
Reviewed-by: Kenneth Graunke <kenneth at whitecape.org>
[snip]
> diff --git a/src/mesa/drivers/dri/i965/genX_state_upload.c b/src/mesa/drivers/dri/i965/genX_state_upload.c
> index 948782a..68b7c29 100644
> --- a/src/mesa/drivers/dri/i965/genX_state_upload.c
> +++ b/src/mesa/drivers/dri/i965/genX_state_upload.c
> @@ -28,6 +28,7 @@
>
> #include "brw_context.h"
> #include "brw_state.h"
> +#include "brw_util.h"
>
> #include "intel_batchbuffer.h"
> #include "intel_fbo.h"
> @@ -111,6 +112,232 @@ __gen_combine_address(struct brw_context *brw, void *location,
> _brw_cmd_pack(cmd)(brw, (void *)_dst, &name), \
> _dst = NULL)
>
> +#if GEN_GEN == 6
> +/**
> + * Determine the appropriate attribute override value to store into the
> + * 3DSTATE_SF structure for a given fragment shader attribute. The attribute
> + * override value contains two pieces of information: the location of the
> + * attribute in the VUE (relative to urb_entry_read_offset, see below), and a
> + * flag indicating whether to "swizzle" the attribute based on the direction
> + * the triangle is facing.
> + *
> + * If an attribute is "swizzled", then the given VUE location is used for
> + * front-facing triangles, and the VUE location that immediately follows is
> + * used for back-facing triangles. We use this to implement the mapping from
> + * gl_FrontColor/gl_BackColor to gl_Color.
> + *
> + * urb_entry_read_offset is the offset into the VUE at which the SF unit is
> + * being instructed to begin reading attribute data. It can be set to a
> + * nonzero value to prevent the SF unit from wasting time reading elements of
> + * the VUE that are not needed by the fragment shader. It is measured in
> + * 256-bit increments.
> + */
> +static void
> +genX(get_attr_override)(struct GENX(SF_OUTPUT_ATTRIBUTE_DETAIL) *attr,
> + const struct brw_vue_map *vue_map,
> + int urb_entry_read_offset, int fs_attr,
> + bool two_side_color, uint32_t *max_source_attr)
> +{
> + /* Find the VUE slot for this attribute. */
> + int slot = vue_map->varying_to_slot[fs_attr];
> +
> + /* Viewport and Layer are stored in the VUE header. We need to override
> + * them to zero if earlier stages didn't write them, as GL requires that
> + * they read back as zero when not explicitly set.
> + */
> + if (fs_attr == VARYING_SLOT_VIEWPORT || fs_attr == VARYING_SLOT_LAYER) {
> + attr->ComponentOverrideX = true;
> + attr->ComponentOverrideW = true;
> + attr->ConstantSource = CONST_0000;
> +
> + if (!(vue_map->slots_valid & VARYING_BIT_LAYER))
> + attr->ComponentOverrideY = true;
> + if (!(vue_map->slots_valid & VARYING_BIT_VIEWPORT))
> + attr->ComponentOverrideZ = true;
> +
> + return;
> + }
> +
> + /* If there was only a back color written but not front, use back
> + * as the color instead of undefined
> + */
> + if (slot == -1 && fs_attr == VARYING_SLOT_COL0)
> + slot = vue_map->varying_to_slot[VARYING_SLOT_BFC0];
> + if (slot == -1 && fs_attr == VARYING_SLOT_COL1)
> + slot = vue_map->varying_to_slot[VARYING_SLOT_BFC1];
> +
> + if (slot == -1) {
> + /* This attribute does not exist in the VUE--that means that the vertex
> + * shader did not write to it. This means that either:
> + *
> + * (a) This attribute is a texture coordinate, and it is going to be
> + * replaced with point coordinates (as a consequence of a call to
> + * glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)), so the
> + * hardware will ignore whatever attribute override we supply.
> + *
> + * (b) This attribute is read by the fragment shader but not written by
> + * the vertex shader, so its value is undefined. Therefore the
> + * attribute override we supply doesn't matter.
> + *
> + * (c) This attribute is gl_PrimitiveID, and it wasn't written by the
> + * previous shader stage.
> + *
> + * Note that we don't have to worry about the cases where the attribute
> + * is gl_PointCoord or is undergoing point sprite coordinate
> + * replacement, because in those cases, this function isn't called.
> + *
> + * In case (c), we need to program the attribute overrides so that the
> + * primitive ID will be stored in this slot. In every other case, the
> + * attribute override we supply doesn't matter. So just go ahead and
> + * program primitive ID in every case.
> + */
> + attr->ComponentOverrideW = true;
> + attr->ComponentOverrideX = true;
> + attr->ComponentOverrideY = true;
> + attr->ComponentOverrideZ = true;
> + attr->ConstantSource = PRIM_ID;
> + return;
> + }
> +
> + /* Compute the location of the attribute relative to urb_entry_read_offset.
> + * Each increment of urb_entry_read_offset represents a 256-bit value, so
> + * it counts for two 128-bit VUE slots.
> + */
> + int source_attr = slot - 2 * urb_entry_read_offset;
> + assert(source_attr >= 0 && source_attr < 32);
> +
> + /* If we are doing two-sided color, and the VUE slot following this one
> + * represents a back-facing color, then we need to instruct the SF unit to
> + * do back-facing swizzling.
> + */
> + bool swizzling = two_side_color &&
> + ((vue_map->slot_to_varying[slot] == VARYING_SLOT_COL0 &&
> + vue_map->slot_to_varying[slot+1] == VARYING_SLOT_BFC0) ||
> + (vue_map->slot_to_varying[slot] == VARYING_SLOT_COL1 &&
> + vue_map->slot_to_varying[slot+1] == VARYING_SLOT_BFC1));
> +
> + /* Update max_source_attr. If swizzling, the SF will read this slot + 1. */
> + if (*max_source_attr < source_attr + swizzling)
> + *max_source_attr = source_attr + swizzling;
> +
> + attr->SourceAttribute = source_attr;
> + if (swizzling)
> + attr->SwizzleSelect = INPUTATTR_FACING;
> +}
> +
> +
> +static void
> +genX(calculate_attr_overrides)(const struct brw_context *brw,
> + struct GENX(SF_OUTPUT_ATTRIBUTE_DETAIL) *attr_overrides,
> + uint32_t *point_sprite_enables,
> + uint32_t *urb_entry_read_length,
> + uint32_t *urb_entry_read_offset)
> +{
> + /* BRW_NEW_FS_PROG_DATA */
> + const struct brw_wm_prog_data *wm_prog_data =
> + brw_wm_prog_data(brw->wm.base.prog_data);
> + uint32_t max_source_attr = 0;
> +
> + *point_sprite_enables = 0;
> +
> + *urb_entry_read_offset = BRW_SF_URB_ENTRY_READ_OFFSET;
Please drop this line - it's pointless - gets overwritten a few lines
below. (This was in the original code too, and is probably my fault!)
> +
> + /* BRW_NEW_FRAGMENT_PROGRAM
> + *
> + * If the fragment shader reads VARYING_SLOT_LAYER, then we need to pass in
> + * the full vertex header. Otherwise, we can program the SF to start
> + * reading at an offset of 1 (2 varying slots) to skip unnecessary data:
> + * - VARYING_SLOT_PSIZ and BRW_VARYING_SLOT_NDC on gen4-5
> + * - VARYING_SLOT_{PSIZ,LAYER} and VARYING_SLOT_POS on gen6+
> + */
> +
> + bool fs_needs_vue_header = brw->fragment_program->info.inputs_read &
> + (VARYING_BIT_LAYER | VARYING_BIT_VIEWPORT);
> +
> + *urb_entry_read_offset = fs_needs_vue_header ? 0 : 1;
> +
> + /* From the Ivybridge PRM, Vol 2 Part 1, 3DSTATE_SBE,
> + * description of dw10 Point Sprite Texture Coordinate Enable:
> + *
> + * "This field must be programmed to zero when non-point primitives
> + * are rendered."
> + *
> + * The SandyBridge PRM doesn't explicitly say that point sprite enables
> + * must be programmed to zero when rendering non-point primitives, but
> + * the IvyBridge PRM does, and if we don't, we get garbage.
> + *
> + * This is not required on Haswell, as the hardware ignores this state
> + * when drawing non-points -- although we do still need to be careful to
> + * correctly set the attr overrides.
> + *
> + * _NEW_POLYGON
> + * BRW_NEW_PRIMITIVE | BRW_NEW_GS_PROG_DATA | BRW_NEW_TES_PROG_DATA
> + */
> + bool drawing_points = brw_is_drawing_points(brw);
> +
> + for (int attr = 0; attr < VARYING_SLOT_MAX; attr++) {
> + int input_index = wm_prog_data->urb_setup[attr];
> +
> + if (input_index < 0)
> + continue;
> +
Let's put this at the top:
struct gl_context *ctx = &brw->ctx;
/* _NEW_POINT */
const struct gl_point_attrib *point = &ctx->Point;
then we can just use point->foo here instead of brw->ctx.Point
which should help keep things <= 78 columns.
> + /* _NEW_POINT */
> + bool point_sprite = false;
> + if (drawing_points) {
> + if (brw->ctx.Point.PointSprite &&
> + (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7) &&
> + (brw->ctx.Point.CoordReplace & (1u << (attr - VARYING_SLOT_TEX0)))) {
> + point_sprite = true;
> + }
> +
> + if (attr == VARYING_SLOT_PNTC)
> + point_sprite = true;
> +
> + if (point_sprite)
> + *point_sprite_enables |= (1 << input_index);
> + }
> +
> + /* BRW_NEW_VUE_MAP_GEOM_OUT | _NEW_LIGHT | _NEW_PROGRAM */
> + struct GENX(SF_OUTPUT_ATTRIBUTE_DETAIL) attribute = { 0 };
> +
> + if (!point_sprite) {
> + genX(get_attr_override)(&attribute,
> + &brw->vue_map_geom_out,
> + *urb_entry_read_offset, attr,
> + brw->ctx.VertexProgram._TwoSideEnabled,
> + &max_source_attr);
> + }
> +
> + /* The hardware can only do the overrides on 16 overrides at a
> + * time, and the other up to 16 have to be lined up so that the
> + * input index = the output index. We'll need to do some
> + * tweaking to make sure that's the case.
> + */
> + if (input_index < 16)
> + attr_overrides[input_index] = attribute;
> + else
> + assert(attribute.SourceAttribute == input_index);
> + }
> +
> + /* From the Sandy Bridge PRM, Volume 2, Part 1, documentation for
> + * 3DSTATE_SF DWord 1 bits 15:11, "Vertex URB Entry Read Length":
> + *
> + * "This field should be set to the minimum length required to read the
> + * maximum source attribute. The maximum source attribute is indicated
> + * by the maximum value of the enabled Attribute # Source Attribute if
> + * Attribute Swizzle Enable is set, Number of Output Attributes-1 if
> + * enable is not set.
> + * read_length = ceiling((max_source_attr + 1) / 2)
> + *
> + * [errata] Corruption/Hang possible if length programmed larger than
> + * recommended"
> + *
> + * Similar text exists for Ivy Bridge.
> + */
> + *urb_entry_read_length = ALIGN(max_source_attr + 1, 2) / 2;
Let's use a newer convenience macro while we're here:
*urb_entry_read_length = DIV_ROUND_UP(max_source_attr + 1, 2);
> +}
> +#endif
> +
> /* ---------------------------------------------------------------------- */
>
> #if GEN_GEN >= 6
> @@ -343,6 +570,201 @@ static const struct brw_tracked_state genX(clip_state) = {
> .emit = genX(upload_clip_state),
> };
>
> +/* ---------------------------------------------------------------------- */
> +
> +static void
> +genX(upload_sf)(struct brw_context *brw)
> +{
> + struct gl_context *ctx = &brw->ctx;
> + float point_size;
> +
> +#if GEN_GEN == 6
Let's combine this block...
> + /* BRW_NEW_FS_PROG_DATA */
> + const struct brw_wm_prog_data *wm_prog_data =
> + brw_wm_prog_data(brw->wm.base.prog_data);
> + uint32_t num_outputs = wm_prog_data->num_varying_inputs;
> +#endif
> +
> +#if GEN_GEN <= 7
> + /* _NEW_BUFFERS */
> + bool render_to_fbo = _mesa_is_user_fbo(ctx->DrawBuffer);
> + const bool multisampled_fbo = _mesa_geometric_samples(ctx->DrawBuffer) > 1;
> +#endif
> +
> + brw_batch_emit(brw, GENX(3DSTATE_SF), sf) {
> + sf.StatisticsEnable = true;
> + sf.ViewportTransformEnable = brw->sf.viewport_transform_enable;
> +
> +#if GEN_GEN <= 6
...and this block...with the block at the end that calls
calculate_attr_overrides(). They're pretty related, and combining them
would reduce the #if/#endif mess a bit.
> + sf.AttributeSwizzleEnable = true;
> + sf.NumberofSFOutputAttributes = num_outputs;
Let's just do:
sf.NumberofSFOutputAttributes = wm_prog_data->num_varying_inputs;
and eliminate num_outputs.
> +
> + /*
> + * Window coordinates in an FBO are inverted, which means point
> + * sprite origin must be inverted, too.
> + */
> + if ((ctx->Point.SpriteOrigin == GL_LOWER_LEFT) != render_to_fbo) {
> + sf.PointSpriteTextureCoordinateOrigin = LOWERLEFT;
> + } else {
> + sf.PointSpriteTextureCoordinateOrigin = UPPERLEFT;
> + }
> +#endif
> +
> +#if GEN_GEN == 7
> + /* _NEW_BUFFERS */
> + sf.DepthBufferSurfaceFormat = brw_depthbuffer_format(brw);
> +#endif
> +
> +#if GEN_GEN <= 7
> + /* _NEW_POLYGON */
> + if (ctx->Polygon._FrontBit == render_to_fbo)
> + sf.FrontWinding = 1;
sf.FrontWinding = true or just set it to the if condition.
> + sf.GlobalDepthOffsetEnableSolid = ctx->Polygon.OffsetFill;
> + sf.GlobalDepthOffsetEnableWireframe = ctx->Polygon.OffsetLine;
> + sf.GlobalDepthOffsetEnablePoint = ctx->Polygon.OffsetPoint;
> +
> + switch (ctx->Polygon.FrontMode) {
> + case GL_FILL:
> + sf.FrontFaceFillMode = FILL_MODE_SOLID;
> + break;
> + case GL_LINE:
> + sf.FrontFaceFillMode = FILL_MODE_WIREFRAME;
> + break;
> + case GL_POINT:
> + sf.FrontFaceFillMode = FILL_MODE_POINT;
> + break;
> + default:
> + unreachable("not reached");
> + }
> +
> + switch (ctx->Polygon.BackMode) {
> + case GL_FILL:
> + sf.BackFaceFillMode = FILL_MODE_SOLID;
> + break;
> + case GL_LINE:
> + sf.BackFaceFillMode = FILL_MODE_WIREFRAME;
> + break;
> + case GL_POINT:
> + sf.BackFaceFillMode = FILL_MODE_POINT;
> + break;
> + default:
> + unreachable("not reached");
> + }
> +
> + sf.ScissorRectangleEnable = true;
> +
> + if (ctx->Polygon.CullFlag) {
> + switch (ctx->Polygon.CullFaceMode) {
> + case GL_FRONT:
> + sf.CullMode = CULLMODE_FRONT;
> + break;
> + case GL_BACK:
> + sf.CullMode = CULLMODE_BACK;
> + break;
> + case GL_FRONT_AND_BACK:
> + sf.CullMode = CULLMODE_BOTH;
> + break;
> + default:
> + unreachable("not reached");
> + }
> + } else {
> + sf.CullMode = CULLMODE_NONE;
> + }
> +
> +#if GEN_IS_HASWELL
> + sf.LineStippleEnable = ctx->Line.StippleFlag;
> +#endif
> +
> + if (multisampled_fbo && ctx->Multisample.Enabled)
> + sf.MultisampleRasterizationMode = MSRASTMODE_ON_PATTERN;
> +
> + /* copied from gen4 */
let's drop this gen4 comment, it's not very useful.
> + sf.GlobalDepthOffsetConstant = ctx->Polygon.OffsetUnits * 2;
> + sf.GlobalDepthOffsetScale = ctx->Polygon.OffsetFactor;
> + sf.GlobalDepthOffsetClamp = ctx->Polygon.OffsetClamp;
> +#endif
> +
> + /* _NEW_LINE */
> + float line_width = brw_get_line_width_float(brw);
> + sf.LineWidth = line_width;
pointless temporary, let's do
sf.LineWidth = brw_get_line_width_float(brw);
> +
> + if (ctx->Line.SmoothFlag) {
> + sf.LineEndCapAntialiasingRegionWidth = _10pixels;
> +#if GEN_GEN <= 7
> + sf.AntiAliasingEnable = true;
> +#endif
> + }
> +
> + /* _NEW_POINT - Clamp to ARB_point_parameters user limits */
> + point_size = CLAMP(ctx->Point.Size, ctx->Point.MinSize, ctx->Point.MaxSize);
> + /* Clamp to the hardware limits */
> + sf.PointWidth = CLAMP(point_size, 0.125f, 255.875f);
> +
> + /* _NEW_PROGRAM | _NEW_POINT, BRW_NEW_VUE_MAP_GEOM_OUT */
> + if (use_state_point_size(brw))
> + sf.PointWidthSource = State;
> +
> +#if GEN_GEN >= 8
> + /* _NEW_POINT | _NEW_MULTISAMPLE */
> + if ((ctx->Point.SmoothFlag || _mesa_is_multisample_enabled(ctx)) &&
> + !ctx->Point.PointSprite)
> + sf.SmoothPointEnable = true;
> +#endif
> +
> +#if GEN_GEN < 7
> + if (ctx->Line.SmoothFlag)
> +#endif
> + sf.AALineDistanceMode = AALINEDISTANCE_TRUE;
Let's set AALINEDISTANCE_TRUE unconditionally. The fact that we don't
on Sandybridge is arguably a bug - I sent a patch to fix that.
> +
> + /* _NEW_LIGHT */
> + if (ctx->Light.ProvokingVertex != GL_FIRST_VERTEX_CONVENTION) {
> + sf.TriangleStripListProvokingVertexSelect = 2;
> + sf.TriangleFanProvokingVertexSelect = 2;
> + sf.LineStripListProvokingVertexSelect = 1;
> + } else {
> + sf.TriangleFanProvokingVertexSelect = 1;
> + }
> +
> +#if GEN_GEN == 6
> + /* BRW_NEW_VUE_MAP_GEOM_OUT | BRW_NEW_FRAGMENT_PROGRAM |
> + * _NEW_POINT | _NEW_LIGHT | _NEW_PROGRAM | BRW_NEW_FS_PROG_DATA
> + */
> + uint32_t urb_entry_read_length;
> + uint32_t urb_entry_read_offset;
> + uint32_t point_sprite_enables;
> + genX(calculate_attr_overrides)(brw, sf.Attribute, &point_sprite_enables,
> + &urb_entry_read_length,
> + &urb_entry_read_offset);
> + sf.VertexURBEntryReadLength = urb_entry_read_length;
> + sf.VertexURBEntryReadOffset = urb_entry_read_offset;
> + sf.PointSpriteTextureCoordinateEnable = point_sprite_enables;
> + sf.ConstantInterpolationEnable = wm_prog_data->flat_inputs;
> +#endif
> + }
> +}
> +
> +static const struct brw_tracked_state genX(sf_state) = {
> + .dirty = {
> + .mesa = _NEW_LIGHT |
> + _NEW_PROGRAM |
> + _NEW_LINE |
Please alphabetize - light, line, multisample, point, program.
(generation specific ones can go at the end)
> + _NEW_MULTISAMPLE |
> + _NEW_POINT |
> + (GEN_GEN <= 7 ? _NEW_BUFFERS | _NEW_POLYGON : 0),
> + .brw = BRW_NEW_BLORP |
> + BRW_NEW_CONTEXT |
> + BRW_NEW_VUE_MAP_GEOM_OUT |
> + (GEN_GEN <= 7 ? BRW_NEW_GS_PROG_DATA |
> + BRW_NEW_PRIMITIVE |
> + BRW_NEW_TES_PROG_DATA
> + : 0) |
> + (GEN_GEN <= 6 ? BRW_NEW_FS_PROG_DATA |
> + BRW_NEW_FRAGMENT_PROGRAM
> + : 0),
GEN_GEN == 6 instead of <= 6 maybe?
> + },
> + .emit = genX(upload_sf),
> +};
> +
> #endif
>
> /* ---------------------------------------------------------------------- */
> @@ -576,7 +998,7 @@ genX(init_atoms)(struct brw_context *brw)
> &gen6_vs_state,
> &gen6_gs_state,
> &genX(clip_state),
> - &gen6_sf_state,
> + &genX(sf_state),
> &gen6_wm_state,
>
> &gen6_scissor_state,
> @@ -665,7 +1087,7 @@ genX(init_atoms)(struct brw_context *brw)
> &gen7_sol_state,
> &genX(clip_state),
> &gen7_sbe_state,
> - &gen7_sf_state,
> + &genX(sf_state),
> &gen7_wm_state,
> &gen7_ps_state,
>
> @@ -753,7 +1175,7 @@ genX(init_atoms)(struct brw_context *brw)
> &genX(clip_state),
> &genX(raster_state),
> &gen8_sbe_state,
> - &gen8_sf_state,
> + &genX(sf_state),
> &gen8_ps_blend,
> &gen8_ps_extra,
> &gen8_ps_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/255b4844/attachment-0001.sig>
More information about the mesa-dev
mailing list