broadcom/vc5: Emit proper flatshading code for glShadeModel(GL_FLAT).

In updating the simulator, behavior changed slightly so that our old code
wasn't getting glxgears's flatshading interpolated right.  Emit flat
shading code just like we would for a normal flat-shaded varying, by
passing a flag in the shader key for glShadeModel(GL_FLAT) state and
customizing the color inputs based on that.

diff --git a/src/broadcom/compiler/nir_to_vir.c b/src/broadcom/compiler/nir_to_vir.c
index 77d460c1b6283d5e49b5253454439fe2202fe251..394e20d2070108f1c6f9164e72b6a43731c29a30 100644 (file)
--- a/src/broadcom/compiler/nir_to_vir.c
+++ b/src/broadcom/compiler/nir_to_vir.c
@@ -614,16 +614,22 @@ emit_fragment_varying(struct v3d_compile *c, nir_variable *var,
         switch (var->data.interpolation) {
         case INTERP_MODE_NONE:
                 /* If a gl_FrontColor or gl_BackColor input has no interp
-                 * qualifier, then flag it for glShadeModel() handling by the
-                 * driver.
+                 * qualifier, then if we're using glShadeModel(GL_FLAT) it
+                 * needs to be flat shaded.
                  */
                 switch (var->data.location) {
                 case VARYING_SLOT_COL0:
                 case VARYING_SLOT_COL1:
                 case VARYING_SLOT_BFC0:
                 case VARYING_SLOT_BFC1:
-                        BITSET_SET(c->shade_model_flags, i);
-                        break;
+                        if (c->fs_key->shade_model_flat) {
+                                BITSET_SET(c->flat_shade_flags, i);
+                                vir_MOV_dest(c, c->undef, vary);
+                                return vir_MOV(c, r5);
+                        } else {
+                                return vir_FADD(c, vir_FMUL(c, vary,
+                                                            c->payload_w), r5);
+                        }
                 default:
                         break;
                 }

diff --git a/src/broadcom/compiler/v3d_compiler.h b/src/broadcom/compiler/v3d_compiler.h
index 7cb2e59b8f7246d07998eac2baf821591471d978..99d58e73ae8f6126f71197125b83bbdaab29135a 100644 (file)
--- a/src/broadcom/compiler/v3d_compiler.h
+++ b/src/broadcom/compiler/v3d_compiler.h
@@ -317,6 +317,7 @@ struct v3d_fs_key {
         bool sample_alpha_to_coverage;
         bool sample_alpha_to_one;
         bool clamp_color;
+        bool shade_model_flat;
         uint8_t nr_cbufs;
         uint8_t swap_color_rb;
         /* Mask of which render targets need to be written as 32-bit floats */
@@ -417,17 +418,11 @@ struct v3d_compile {
         uint32_t uniforms_array_size;
 
         /* Booleans for whether the corresponding QFILE_VARY[i] is
-         * flat-shaded.  This doesn't count gl_FragColor flat-shading, which is
-         * controlled by shader->color_inputs and rasterizer->flatshade in the
-         * gallium driver.
+         * flat-shaded.  This includes gl_FragColor flat-shading, which is
+         * customized based on the shademodel_flat shader key.
          */
         BITSET_WORD flat_shade_flags[BITSET_WORDS(V3D_MAX_FS_INPUTS)];
 
-        /* Booleans for whether the corresponding QFILE_VARY[i] uses the
-         * default glShadeModel() behavior.
-         */
-        BITSET_WORD shade_model_flags[BITSET_WORDS(V3D_MAX_FS_INPUTS)];
-
         struct v3d_ubo_range *ubo_ranges;
         bool *ubo_range_used;
         uint32_t ubo_ranges_array_size;
@@ -574,14 +569,9 @@ struct v3d_fs_prog_data {
 
         struct v3d_varying_slot input_slots[V3D_MAX_FS_INPUTS];
 
-        /* Bitmask for whether the corresponding input is flat-shaded,
-         * independent of rasterizer (gl_FragColor) flat-shading.
+        /* Bitmask for whether the corresponding input is flat-shaded.
          */
         BITSET_WORD flat_shade_flags[BITSET_WORDS(V3D_MAX_FS_INPUTS)];
-        /* Bitmask for whether the corresponding input uses the default
-         * glShadeModel() behavior.
-         */
-        BITSET_WORD shade_model_flags[BITSET_WORDS(V3D_MAX_FS_INPUTS)];
 
         bool writes_z;
         bool discard;

diff --git a/src/broadcom/compiler/vir.c b/src/broadcom/compiler/vir.c
index d95a150c720a02e196eed5be1a55f43bbba62471..2589c7f554d273c7d9661ca676918fc9f4e445e2 100644 (file)
--- a/src/broadcom/compiler/vir.c
+++ b/src/broadcom/compiler/vir.c
@@ -716,8 +716,6 @@ v3d_set_fs_prog_data_inputs(struct v3d_compile *c,
 
         memcpy(prog_data->flat_shade_flags, c->flat_shade_flags,
                sizeof(c->flat_shade_flags));
-        memcpy(prog_data->shade_model_flags, c->shade_model_flags,
-               sizeof(c->shade_model_flags));
 }
 
 uint64_t *v3d_compile_fs(const struct v3d_compiler *compiler,

diff --git a/src/gallium/drivers/vc5/vc5_emit.c b/src/gallium/drivers/vc5/vc5_emit.c
index 413059efa4a4b06ec5e6794920f24ad40c4dcd9c..3914a346e9d36a437b9806a40d3803f5e6509a67 100644 (file)
--- a/src/gallium/drivers/vc5/vc5_emit.c
+++ b/src/gallium/drivers/vc5/vc5_emit.c
@@ -507,11 +507,6 @@ vc5_emit_state(struct pipe_context *pctx)
 
                         flags.flat_shade_flags_for_varyings_v024 =
                                 vc5->prog.fs->prog_data.fs->flat_shade_flags[0] & 0xfffff;
-
-                        if (vc5->rasterizer->base.flatshade) {
-                                flags.flat_shade_flags_for_varyings_v024 |=
-                                        vc5->prog.fs->prog_data.fs->shade_model_flags[0] & 0xfffff;
-                        }
                 }
         }
 

diff --git a/src/gallium/drivers/vc5/vc5_program.c b/src/gallium/drivers/vc5/vc5_program.c
index 4232d6aeb83f539298acb72816ede4cffee25c61..2fbd83982cd5ea7783305bdcefd3753c0b7a2111 100644 (file)
--- a/src/gallium/drivers/vc5/vc5_program.c
+++ b/src/gallium/drivers/vc5/vc5_program.c
@@ -390,6 +390,7 @@ vc5_update_compiled_fs(struct vc5_context *vc5, uint8_t prim_mode)
         }
 
         key->light_twoside = vc5->rasterizer->base.light_twoside;
+        key->shade_model_flat = vc5->rasterizer->base.flatshade;
 
         struct vc5_compiled_shader *old_fs = vc5->prog.fs;
         vc5->prog.fs = vc5_get_compiled_shader(vc5, &key->base);
@@ -399,11 +400,8 @@ vc5_update_compiled_fs(struct vc5_context *vc5, uint8_t prim_mode)
         vc5->dirty |= VC5_DIRTY_COMPILED_FS;
 
         if (old_fs &&
-            (vc5->prog.fs->prog_data.fs->flat_shade_flags !=
-             old_fs->prog_data.fs->flat_shade_flags ||
-             (vc5->rasterizer->base.flatshade &&
-              vc5->prog.fs->prog_data.fs->shade_model_flags !=
-              old_fs->prog_data.fs->shade_model_flags))) {
+            vc5->prog.fs->prog_data.fs->flat_shade_flags !=
+            old_fs->prog_data.fs->flat_shade_flags) {
                 vc5->dirty |= VC5_DIRTY_FLAT_SHADE_FLAGS;
         }
 

diff --git a/src/gallium/drivers/vc5/vc5_state.c b/src/gallium/drivers/vc5/vc5_state.c
index 8bc575f6f1d0c62079e96d642c2d798d07026ef4..a3ae2b3f539f23a7606f46bb5c7d0bd6bbf36313 100644 (file)
--- a/src/gallium/drivers/vc5/vc5_state.c
+++ b/src/gallium/drivers/vc5/vc5_state.c
@@ -272,13 +272,6 @@ static void
 vc5_rasterizer_state_bind(struct pipe_context *pctx, void *hwcso)
 {
         struct vc5_context *vc5 = vc5_context(pctx);
-        struct vc5_rasterizer_state *rast = hwcso;
-
-        if (vc5->rasterizer && rast &&
-            vc5->rasterizer->base.flatshade != rast->base.flatshade) {
-                vc5->dirty |= VC5_DIRTY_FLAT_SHADE_FLAGS;
-        }
-
         vc5->rasterizer = hwcso;
         vc5->dirty |= VC5_DIRTY_RASTERIZER;
 }