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

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a copy of this software and associated documentation files (the
   8  "Software"), to deal in the Software without restriction, including
   9  without limitation the rights to use, copy, modify, merge, publish,
  10  distribute, sublicense, and/or sell copies of the Software, and to
  11  permit persons to whom the Software is furnished to do so, subject to
  12  the following conditions:
  13
  14  The above copyright notice and this permission notice (including the
  15  next paragraph) shall be included in all copies or substantial
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keithw@vmware.com>
  30   */
  31
  32 #include "brw_context.h"
  33 #include "brw_wm.h"
  34 #include "brw_state.h"
  35 #include "main/enums.h"
  36 #include "main/formats.h"
  37 #include "main/fbobject.h"
  38 #include "main/samplerobj.h"
  39 #include "program/prog_parameter.h"
  40 #include "program/program.h"
  41 #include "intel_mipmap_tree.h"
  42
  43 #include "util/ralloc.h"
  44
  45 /**
  46  * Return a bitfield where bit n is set if barycentric interpolation mode n
  47  * (see enum brw_wm_barycentric_interp_mode) is needed by the fragment shader.
  48  */
  49 static unsigned
  50 brw_compute_barycentric_interp_modes(struct brw_context *brw,
  51                                      bool shade_model_flat,
  52                                      bool persample_shading,
  53                                      const struct gl_fragment_program *fprog)
  54 {
  55    unsigned barycentric_interp_modes = 0;
  56    int attr;
  57
  58    /* Loop through all fragment shader inputs to figure out what interpolation
  59     * modes are in use, and set the appropriate bits in
  60     * barycentric_interp_modes.
  61     */
  62    for (attr = 0; attr < VARYING_SLOT_MAX; ++attr) {
  63       enum glsl_interp_qualifier interp_qualifier =
  64          fprog->InterpQualifier[attr];
  65       bool is_centroid = (fprog->IsCentroid & BITFIELD64_BIT(attr)) &&
  66          !persample_shading;
  67       bool is_sample = (fprog->IsSample & BITFIELD64_BIT(attr)) ||
  68          persample_shading;
  69       bool is_gl_Color = attr == VARYING_SLOT_COL0 || attr == VARYING_SLOT_COL1;
  70
  71       /* Ignore unused inputs. */
  72       if (!(fprog->Base.InputsRead & BITFIELD64_BIT(attr)))
  73          continue;
  74
  75       /* Ignore WPOS and FACE, because they don't require interpolation. */
  76       if (attr == VARYING_SLOT_POS || attr == VARYING_SLOT_FACE)
  77          continue;
  78
  79       /* Determine the set (or sets) of barycentric coordinates needed to
  80        * interpolate this variable.  Note that when
  81        * brw->needs_unlit_centroid_workaround is set, centroid interpolation
  82        * uses PIXEL interpolation for unlit pixels and CENTROID interpolation
  83        * for lit pixels, so we need both sets of barycentric coordinates.
  84        */
  85       if (interp_qualifier == INTERP_QUALIFIER_NOPERSPECTIVE) {
  86          if (is_centroid) {
  87             barycentric_interp_modes |=
  88                1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC;
  89          } else if (is_sample) {
  90             barycentric_interp_modes |=
  91                1 << BRW_WM_NONPERSPECTIVE_SAMPLE_BARYCENTRIC;
  92          }
  93          if ((!is_centroid && !is_sample) ||
  94              brw->needs_unlit_centroid_workaround) {
  95             barycentric_interp_modes |=
  96                1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC;
  97          }
  98       } else if (interp_qualifier == INTERP_QUALIFIER_SMOOTH ||
  99                  (!(shade_model_flat && is_gl_Color) &&
 100                   interp_qualifier == INTERP_QUALIFIER_NONE)) {
 101          if (is_centroid) {
 102             barycentric_interp_modes |=
 103                1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC;
 104          } else if (is_sample) {
 105             barycentric_interp_modes |=
 106                1 << BRW_WM_PERSPECTIVE_SAMPLE_BARYCENTRIC;
 107          }
 108          if ((!is_centroid && !is_sample) ||
 109              brw->needs_unlit_centroid_workaround) {
 110             barycentric_interp_modes |=
 111                1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC;
 112          }
 113       }
 114    }
 115
 116    return barycentric_interp_modes;
 117 }
 118
 119 static uint8_t
 120 computed_depth_mode(struct gl_fragment_program *fp)
 121 {
 122    if (fp->Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 123       switch (fp->FragDepthLayout) {
 124       case FRAG_DEPTH_LAYOUT_NONE:
 125       case FRAG_DEPTH_LAYOUT_ANY:
 126          return BRW_PSCDEPTH_ON;
 127       case FRAG_DEPTH_LAYOUT_GREATER:
 128          return BRW_PSCDEPTH_ON_GE;
 129       case FRAG_DEPTH_LAYOUT_LESS:
 130          return BRW_PSCDEPTH_ON_LE;
 131       case FRAG_DEPTH_LAYOUT_UNCHANGED:
 132          return BRW_PSCDEPTH_OFF;
 133       }
 134    }
 135    return BRW_PSCDEPTH_OFF;
 136 }
 137
 138 bool
 139 brw_wm_prog_data_compare(const void *in_a, const void *in_b)
 140 {
 141    const struct brw_wm_prog_data *a = in_a;
 142    const struct brw_wm_prog_data *b = in_b;
 143
 144    /* Compare the base structure. */
 145    if (!brw_stage_prog_data_compare(&a->base, &b->base))
 146       return false;
 147
 148    /* Compare the rest of the structure. */
 149    const unsigned offset = sizeof(struct brw_stage_prog_data);
 150    if (memcmp(((char *) a) + offset, ((char *) b) + offset,
 151               sizeof(struct brw_wm_prog_data) - offset))
 152       return false;
 153
 154    return true;
 155 }
 156
 157 /**
 158  * All Mesa program -> GPU code generation goes through this function.
 159  * Depending on the instructions used (i.e. flow control instructions)
 160  * we'll use one of two code generators.
 161  */
 162 bool do_wm_prog(struct brw_context *brw,
 163                 struct gl_shader_program *prog,
 164                 struct brw_fragment_program *fp,
 165                 struct brw_wm_prog_key *key)
 166 {
 167    struct gl_context *ctx = &brw->ctx;
 168    void *mem_ctx = ralloc_context(NULL);
 169    struct brw_wm_prog_data prog_data;
 170    const GLuint *program;
 171    struct gl_shader *fs = NULL;
 172    GLuint program_size;
 173
 174    if (prog)
 175       fs = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
 176
 177    memset(&prog_data, 0, sizeof(prog_data));
 178    /* key->alpha_test_func means simulating alpha testing via discards,
 179     * so the shader definitely kills pixels.
 180     */
 181    prog_data.uses_kill = fp->program.UsesKill || key->alpha_test_func;
 182
 183    prog_data.computed_depth_mode = computed_depth_mode(&fp->program);
 184
 185    /* Use ALT floating point mode for ARB programs so that 0^0 == 1. */
 186    if (!prog)
 187       prog_data.base.use_alt_mode = true;
 188
 189    /* Allocate the references to the uniforms that will end up in the
 190     * prog_data associated with the compiled program, and which will be freed
 191     * by the state cache.
 192     */
 193    int param_count;
 194    if (fs) {
 195       param_count = fs->num_uniform_components;
 196    } else {
 197       param_count = fp->program.Base.Parameters->NumParameters * 4;
 198    }
 199    /* The backend also sometimes adds params for texture size. */
 200    param_count += 2 * ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits;
 201    prog_data.base.param =
 202       rzalloc_array(NULL, const gl_constant_value *, param_count);
 203    prog_data.base.pull_param =
 204       rzalloc_array(NULL, const gl_constant_value *, param_count);
 205    prog_data.base.nr_params = param_count;
 206
 207    prog_data.barycentric_interp_modes =
 208       brw_compute_barycentric_interp_modes(brw, key->flat_shade,
 209                                            key->persample_shading,
 210                                            &fp->program);
 211
 212    program = brw_wm_fs_emit(brw, mem_ctx, key, &prog_data,
 213                             &fp->program, prog, &program_size);
 214    if (program == NULL) {
 215       ralloc_free(mem_ctx);
 216       return false;
 217    }
 218
 219    if (prog_data.base.total_scratch) {
 220       brw_get_scratch_bo(brw, &brw->wm.base.scratch_bo,
 221                          prog_data.base.total_scratch * brw->max_wm_threads);
 222    }
 223
 224    if (unlikely(INTEL_DEBUG & DEBUG_WM))
 225       fprintf(stderr, "\n");
 226
 227    brw_upload_cache(&brw->cache, BRW_CACHE_FS_PROG,
 228                     key, sizeof(struct brw_wm_prog_key),
 229                     program, program_size,
 230                     &prog_data, sizeof(prog_data),
 231                     &brw->wm.base.prog_offset, &brw->wm.prog_data);
 232
 233    ralloc_free(mem_ctx);
 234
 235    return true;
 236 }
 237
 238 static bool
 239 key_debug(struct brw_context *brw, const char *name, int a, int b)
 240 {
 241    if (a != b) {
 242       perf_debug("  %s %d->%d\n", name, a, b);
 243       return true;
 244    } else {
 245       return false;
 246    }
 247 }
 248
 249 bool
 250 brw_debug_recompile_sampler_key(struct brw_context *brw,
 251                                 const struct brw_sampler_prog_key_data *old_key,
 252                                 const struct brw_sampler_prog_key_data *key)
 253 {
 254    bool found = false;
 255
 256    for (unsigned int i = 0; i < MAX_SAMPLERS; i++) {
 257       found |= key_debug(brw, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE",
 258                          old_key->swizzles[i], key->swizzles[i]);
 259    }
 260    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 1st coordinate",
 261                       old_key->gl_clamp_mask[0], key->gl_clamp_mask[0]);
 262    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 2nd coordinate",
 263                       old_key->gl_clamp_mask[1], key->gl_clamp_mask[1]);
 264    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 3rd coordinate",
 265                       old_key->gl_clamp_mask[2], key->gl_clamp_mask[2]);
 266    found |= key_debug(brw, "gather channel quirk on any texture unit",
 267                       old_key->gather_channel_quirk_mask, key->gather_channel_quirk_mask);
 268
 269    return found;
 270 }
 271
 272 void
 273 brw_wm_debug_recompile(struct brw_context *brw,
 274                        struct gl_shader_program *prog,
 275                        const struct brw_wm_prog_key *key)
 276 {
 277    struct brw_cache_item *c = NULL;
 278    const struct brw_wm_prog_key *old_key = NULL;
 279    bool found = false;
 280
 281    perf_debug("Recompiling fragment shader for program %d\n", prog->Name);
 282
 283    for (unsigned int i = 0; i < brw->cache.size; i++) {
 284       for (c = brw->cache.items[i]; c; c = c->next) {
 285          if (c->cache_id == BRW_CACHE_FS_PROG) {
 286             old_key = c->key;
 287
 288             if (old_key->program_string_id == key->program_string_id)
 289                break;
 290          }
 291       }
 292       if (c)
 293          break;
 294    }
 295
 296    if (!c) {
 297       perf_debug("  Didn't find previous compile in the shader cache for debug\n");
 298       return;
 299    }
 300
 301    found |= key_debug(brw, "alphatest, computed depth, depth test, or "
 302                       "depth write",
 303                       old_key->iz_lookup, key->iz_lookup);
 304    found |= key_debug(brw, "depth statistics",
 305                       old_key->stats_wm, key->stats_wm);
 306    found |= key_debug(brw, "flat shading",
 307                       old_key->flat_shade, key->flat_shade);
 308    found |= key_debug(brw, "per-sample shading",
 309                       old_key->persample_shading, key->persample_shading);
 310    found |= key_debug(brw, "per-sample shading and 2x MSAA",
 311                       old_key->persample_2x, key->persample_2x);
 312    found |= key_debug(brw, "number of color buffers",
 313                       old_key->nr_color_regions, key->nr_color_regions);
 314    found |= key_debug(brw, "MRT alpha test or alpha-to-coverage",
 315                       old_key->replicate_alpha, key->replicate_alpha);
 316    found |= key_debug(brw, "rendering to FBO",
 317                       old_key->render_to_fbo, key->render_to_fbo);
 318    found |= key_debug(brw, "fragment color clamping",
 319                       old_key->clamp_fragment_color, key->clamp_fragment_color);
 320    found |= key_debug(brw, "line smoothing",
 321                       old_key->line_aa, key->line_aa);
 322    found |= key_debug(brw, "renderbuffer height",
 323                       old_key->drawable_height, key->drawable_height);
 324    found |= key_debug(brw, "input slots valid",
 325                       old_key->input_slots_valid, key->input_slots_valid);
 326    found |= key_debug(brw, "mrt alpha test function",
 327                       old_key->alpha_test_func, key->alpha_test_func);
 328    found |= key_debug(brw, "mrt alpha test reference value",
 329                       old_key->alpha_test_ref, key->alpha_test_ref);
 330
 331    found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex);
 332
 333    if (!found) {
 334       perf_debug("  Something else\n");
 335    }
 336 }
 337
 338 static uint8_t
 339 gen6_gather_workaround(GLenum internalformat)
 340 {
 341    switch (internalformat) {
 342       case GL_R8I: return WA_SIGN | WA_8BIT;
 343       case GL_R8UI: return WA_8BIT;
 344       case GL_R16I: return WA_SIGN | WA_16BIT;
 345       case GL_R16UI: return WA_16BIT;
 346       /* note that even though GL_R32I and GL_R32UI have format overrides
 347        * in the surface state, there is no shader w/a required */
 348       default: return 0;
 349    }
 350 }
 351
 352 void
 353 brw_populate_sampler_prog_key_data(struct gl_context *ctx,
 354                                    const struct gl_program *prog,
 355                                    unsigned sampler_count,
 356                                    struct brw_sampler_prog_key_data *key)
 357 {
 358    struct brw_context *brw = brw_context(ctx);
 359
 360    for (int s = 0; s < sampler_count; s++) {
 361       key->swizzles[s] = SWIZZLE_NOOP;
 362
 363       if (!(prog->SamplersUsed & (1 << s)))
 364          continue;
 365
 366       int unit_id = prog->SamplerUnits[s];
 367       const struct gl_texture_unit *unit = &ctx->Texture.Unit[unit_id];
 368
 369       if (unit->_Current && unit->_Current->Target != GL_TEXTURE_BUFFER) {
 370          const struct gl_texture_object *t = unit->_Current;
 371          const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
 372          struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit_id);
 373
 374          const bool alpha_depth = t->DepthMode == GL_ALPHA &&
 375             (img->_BaseFormat == GL_DEPTH_COMPONENT ||
 376              img->_BaseFormat == GL_DEPTH_STENCIL);
 377
 378          /* Haswell handles texture swizzling as surface format overrides
 379           * (except for GL_ALPHA); all other platforms need MOVs in the shader.
 380           */
 381          if (alpha_depth || (brw->gen < 8 && !brw->is_haswell))
 382             key->swizzles[s] = brw_get_texture_swizzle(ctx, t);
 383
 384          if (brw->gen < 8 &&
 385              sampler->MinFilter != GL_NEAREST &&
 386              sampler->MagFilter != GL_NEAREST) {
 387             if (sampler->WrapS == GL_CLAMP)
 388                key->gl_clamp_mask[0] |= 1 << s;
 389             if (sampler->WrapT == GL_CLAMP)
 390                key->gl_clamp_mask[1] |= 1 << s;
 391             if (sampler->WrapR == GL_CLAMP)
 392                key->gl_clamp_mask[2] |= 1 << s;
 393          }
 394
 395          /* gather4's channel select for green from RG32F is broken;
 396           * requires a shader w/a on IVB; fixable with just SCS on HSW. */
 397          if (brw->gen == 7 && !brw->is_haswell && prog->UsesGather) {
 398             if (img->InternalFormat == GL_RG32F)
 399                key->gather_channel_quirk_mask |= 1 << s;
 400          }
 401
 402          /* Gen6's gather4 is broken for UINT/SINT; we treat them as
 403           * UNORM/FLOAT instead and fix it in the shader.
 404           */
 405          if (brw->gen == 6 && prog->UsesGather) {
 406             key->gen6_gather_wa[s] = gen6_gather_workaround(img->InternalFormat);
 407          }
 408
 409          /* If this is a multisample sampler, and uses the CMS MSAA layout,
 410           * then we need to emit slightly different code to first sample the
 411           * MCS surface.
 412           */
 413          struct intel_texture_object *intel_tex =
 414             intel_texture_object((struct gl_texture_object *)t);
 415
 416          if (brw->gen >= 7 &&
 417              intel_tex->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) {
 418             key->compressed_multisample_layout_mask |= 1 << s;
 419          }
 420       }
 421    }
 422 }
 423
 424 static void brw_wm_populate_key( struct brw_context *brw,
 425                                  struct brw_wm_prog_key *key )
 426 {
 427    struct gl_context *ctx = &brw->ctx;
 428    /* BRW_NEW_FRAGMENT_PROGRAM */
 429    const struct brw_fragment_program *fp =
 430       (struct brw_fragment_program *)brw->fragment_program;
 431    const struct gl_program *prog = (struct gl_program *) brw->fragment_program;
 432    GLuint lookup = 0;
 433    GLuint line_aa;
 434    bool program_uses_dfdy = fp->program.UsesDFdy;
 435    bool multisample_fbo = ctx->DrawBuffer->Visual.samples > 1;
 436
 437    memset(key, 0, sizeof(*key));
 438
 439    /* Build the index for table lookup
 440     */
 441    if (brw->gen < 6) {
 442       /* _NEW_COLOR */
 443       if (fp->program.UsesKill || ctx->Color.AlphaEnabled)
 444          lookup |= IZ_PS_KILL_ALPHATEST_BIT;
 445
 446       if (fp->program.Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
 447          lookup |= IZ_PS_COMPUTES_DEPTH_BIT;
 448
 449       /* _NEW_DEPTH */
 450       if (ctx->Depth.Test)
 451          lookup |= IZ_DEPTH_TEST_ENABLE_BIT;
 452
 453       if (ctx->Depth.Test && ctx->Depth.Mask) /* ?? */
 454          lookup |= IZ_DEPTH_WRITE_ENABLE_BIT;
 455
 456       /* _NEW_STENCIL | _NEW_BUFFERS */
 457       if (ctx->Stencil._Enabled) {
 458          lookup |= IZ_STENCIL_TEST_ENABLE_BIT;
 459
 460          if (ctx->Stencil.WriteMask[0] ||
 461              ctx->Stencil.WriteMask[ctx->Stencil._BackFace])
 462             lookup |= IZ_STENCIL_WRITE_ENABLE_BIT;
 463       }
 464       key->iz_lookup = lookup;
 465    }
 466
 467    line_aa = AA_NEVER;
 468
 469    /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
 470    if (ctx->Line.SmoothFlag) {
 471       if (brw->reduced_primitive == GL_LINES) {
 472          line_aa = AA_ALWAYS;
 473       }
 474       else if (brw->reduced_primitive == GL_TRIANGLES) {
 475          if (ctx->Polygon.FrontMode == GL_LINE) {
 476             line_aa = AA_SOMETIMES;
 477
 478             if (ctx->Polygon.BackMode == GL_LINE ||
 479                 (ctx->Polygon.CullFlag &&
 480                  ctx->Polygon.CullFaceMode == GL_BACK))
 481                line_aa = AA_ALWAYS;
 482          }
 483          else if (ctx->Polygon.BackMode == GL_LINE) {
 484             line_aa = AA_SOMETIMES;
 485
 486             if ((ctx->Polygon.CullFlag &&
 487                  ctx->Polygon.CullFaceMode == GL_FRONT))
 488                line_aa = AA_ALWAYS;
 489          }
 490       }
 491    }
 492
 493    key->line_aa = line_aa;
 494
 495    /* _NEW_HINT */
 496    key->high_quality_derivatives =
 497       ctx->Hint.FragmentShaderDerivative == GL_NICEST;
 498
 499    if (brw->gen < 6)
 500       key->stats_wm = brw->stats_wm;
 501
 502    /* _NEW_LIGHT */
 503    key->flat_shade = (ctx->Light.ShadeModel == GL_FLAT);
 504
 505    /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */
 506    key->clamp_fragment_color = ctx->Color._ClampFragmentColor;
 507
 508    /* _NEW_TEXTURE */
 509    brw_populate_sampler_prog_key_data(ctx, prog, brw->wm.base.sampler_count,
 510                                       &key->tex);
 511
 512    /* _NEW_BUFFERS */
 513    /*
 514     * Include the draw buffer origin and height so that we can calculate
 515     * fragment position values relative to the bottom left of the drawable,
 516     * from the incoming screen origin relative position we get as part of our
 517     * payload.
 518     *
 519     * This is only needed for the WM_WPOSXY opcode when the fragment program
 520     * uses the gl_FragCoord input.
 521     *
 522     * We could avoid recompiling by including this as a constant referenced by
 523     * our program, but if we were to do that it would also be nice to handle
 524     * getting that constant updated at batchbuffer submit time (when we
 525     * hold the lock and know where the buffer really is) rather than at emit
 526     * time when we don't hold the lock and are just guessing.  We could also
 527     * just avoid using this as key data if the program doesn't use
 528     * fragment.position.
 529     *
 530     * For DRI2 the origin_x/y will always be (0,0) but we still need the
 531     * drawable height in order to invert the Y axis.
 532     */
 533    if (fp->program.Base.InputsRead & VARYING_BIT_POS) {
 534       key->drawable_height = ctx->DrawBuffer->Height;
 535    }
 536
 537    if ((fp->program.Base.InputsRead & VARYING_BIT_POS) || program_uses_dfdy) {
 538       key->render_to_fbo = _mesa_is_user_fbo(ctx->DrawBuffer);
 539    }
 540
 541    /* _NEW_BUFFERS */
 542    key->nr_color_regions = ctx->DrawBuffer->_NumColorDrawBuffers;
 543
 544    /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */
 545    key->replicate_alpha = ctx->DrawBuffer->_NumColorDrawBuffers > 1 &&
 546       (ctx->Multisample.SampleAlphaToCoverage || ctx->Color.AlphaEnabled);
 547
 548    /* _NEW_BUFFERS _NEW_MULTISAMPLE */
 549    /* Ignore sample qualifier while computing this flag. */
 550    key->persample_shading =
 551       _mesa_get_min_invocations_per_fragment(ctx, &fp->program, true) > 1;
 552    if (key->persample_shading)
 553       key->persample_2x = ctx->DrawBuffer->Visual.samples == 2;
 554
 555    key->compute_pos_offset =
 556       _mesa_get_min_invocations_per_fragment(ctx, &fp->program, false) > 1 &&
 557       fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_POS;
 558
 559    key->compute_sample_id =
 560       multisample_fbo &&
 561       ctx->Multisample.Enabled &&
 562       (fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_ID);
 563
 564    /* BRW_NEW_VUE_MAP_GEOM_OUT */
 565    if (brw->gen < 6 || _mesa_bitcount_64(fp->program.Base.InputsRead &
 566                                          BRW_FS_VARYING_INPUT_MASK) > 16)
 567       key->input_slots_valid = brw->vue_map_geom_out.slots_valid;
 568
 569
 570    /* _NEW_COLOR | _NEW_BUFFERS */
 571    /* Pre-gen6, the hardware alpha test always used each render
 572     * target's alpha to do alpha test, as opposed to render target 0's alpha
 573     * like GL requires.  Fix that by building the alpha test into the
 574     * shader, and we'll skip enabling the fixed function alpha test.
 575     */
 576    if (brw->gen < 6 && ctx->DrawBuffer->_NumColorDrawBuffers > 1 && ctx->Color.AlphaEnabled) {
 577       key->alpha_test_func = ctx->Color.AlphaFunc;
 578       key->alpha_test_ref = ctx->Color.AlphaRef;
 579    }
 580
 581    /* The unique fragment program ID */
 582    key->program_string_id = fp->id;
 583 }
 584
 585
 586 static void
 587 brw_upload_wm_prog(struct brw_context *brw)
 588 {
 589    struct gl_context *ctx = &brw->ctx;
 590    struct brw_wm_prog_key key;
 591    struct brw_fragment_program *fp = (struct brw_fragment_program *)
 592       brw->fragment_program;
 593
 594    brw_wm_populate_key(brw, &key);
 595
 596    if (!brw_search_cache(&brw->cache, BRW_CACHE_FS_PROG,
 597                          &key, sizeof(key),
 598                          &brw->wm.base.prog_offset, &brw->wm.prog_data)) {
 599       bool success = do_wm_prog(brw, ctx->_Shader->_CurrentFragmentProgram, fp,
 600                                 &key);
 601       (void) success;
 602       assert(success);
 603    }
 604    brw->wm.base.prog_data = &brw->wm.prog_data->base;
 605 }
 606
 607
 608 const struct brw_tracked_state brw_wm_prog = {
 609    .dirty = {
 610       .mesa  = _NEW_BUFFERS |
 611                _NEW_COLOR |
 612                _NEW_DEPTH |
 613                _NEW_FRAG_CLAMP |
 614                _NEW_HINT |
 615                _NEW_LIGHT |
 616                _NEW_LINE |
 617                _NEW_MULTISAMPLE |
 618                _NEW_POLYGON |
 619                _NEW_STENCIL |
 620                _NEW_TEXTURE,
 621       .brw   = BRW_NEW_FRAGMENT_PROGRAM |
 622                BRW_NEW_REDUCED_PRIMITIVE |
 623                BRW_NEW_STATS_WM |
 624                BRW_NEW_VUE_MAP_GEOM_OUT,
 625    },
 626    .emit = brw_upload_wm_prog
 627 };
 628