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 "glsl/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 bool
 120 brw_wm_prog_data_compare(const void *in_a, const void *in_b)
 121 {
 122    const struct brw_wm_prog_data *a = in_a;
 123    const struct brw_wm_prog_data *b = in_b;
 124
 125    /* Compare the base structure. */
 126    if (!brw_stage_prog_data_compare(&a->base, &b->base))
 127       return false;
 128
 129    /* Compare the rest of the structure. */
 130    const unsigned offset = sizeof(struct brw_stage_prog_data);
 131    if (memcmp(((char *) a) + offset, ((char *) b) + offset,
 132               sizeof(struct brw_wm_prog_data) - offset))
 133       return false;
 134
 135    return true;
 136 }
 137
 138 /**
 139  * All Mesa program -> GPU code generation goes through this function.
 140  * Depending on the instructions used (i.e. flow control instructions)
 141  * we'll use one of two code generators.
 142  */
 143 bool do_wm_prog(struct brw_context *brw,
 144                 struct gl_shader_program *prog,
 145                 struct brw_fragment_program *fp,
 146                 struct brw_wm_prog_key *key)
 147 {
 148    struct gl_context *ctx = &brw->ctx;
 149    struct brw_wm_compile *c;
 150    const GLuint *program;
 151    struct gl_shader *fs = NULL;
 152    GLuint program_size;
 153
 154    if (prog)
 155       fs = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
 156
 157    c = rzalloc(NULL, struct brw_wm_compile);
 158
 159    /* Allocate the references to the uniforms that will end up in the
 160     * prog_data associated with the compiled program, and which will be freed
 161     * by the state cache.
 162     */
 163    int param_count;
 164    if (fs) {
 165       param_count = fs->num_uniform_components;
 166    } else {
 167       param_count = fp->program.Base.Parameters->NumParameters * 4;
 168    }
 169    /* The backend also sometimes adds params for texture size. */
 170    param_count += 2 * ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits;
 171    c->prog_data.base.param = rzalloc_array(NULL, const float *, param_count);
 172    c->prog_data.base.pull_param =
 173       rzalloc_array(NULL, const float *, param_count);
 174    c->prog_data.base.nr_params = param_count;
 175
 176    memcpy(&c->key, key, sizeof(*key));
 177
 178    c->prog_data.barycentric_interp_modes =
 179       brw_compute_barycentric_interp_modes(brw, c->key.flat_shade,
 180                                            c->key.persample_shading,
 181                                            &fp->program);
 182
 183    program = brw_wm_fs_emit(brw, c, &fp->program, prog, &program_size);
 184    if (program == NULL)
 185       return false;
 186
 187    /* Scratch space is used for register spilling */
 188    if (c->last_scratch) {
 189       perf_debug("Fragment shader triggered register spilling.  "
 190                  "Try reducing the number of live scalar values to "
 191                  "improve performance.\n");
 192
 193       c->prog_data.total_scratch = brw_get_scratch_size(c->last_scratch);
 194
 195       brw_get_scratch_bo(brw, &brw->wm.base.scratch_bo,
 196                          c->prog_data.total_scratch * brw->max_wm_threads);
 197    }
 198
 199    if (unlikely(INTEL_DEBUG & DEBUG_WM))
 200       fprintf(stderr, "\n");
 201
 202    brw_upload_cache(&brw->cache, BRW_WM_PROG,
 203                     &c->key, sizeof(c->key),
 204                     program, program_size,
 205                     &c->prog_data, sizeof(c->prog_data),
 206                     &brw->wm.base.prog_offset, &brw->wm.prog_data);
 207
 208    ralloc_free(c);
 209
 210    return true;
 211 }
 212
 213 static bool
 214 key_debug(struct brw_context *brw, const char *name, int a, int b)
 215 {
 216    if (a != b) {
 217       perf_debug("  %s %d->%d\n", name, a, b);
 218       return true;
 219    } else {
 220       return false;
 221    }
 222 }
 223
 224 bool
 225 brw_debug_recompile_sampler_key(struct brw_context *brw,
 226                                 const struct brw_sampler_prog_key_data *old_key,
 227                                 const struct brw_sampler_prog_key_data *key)
 228 {
 229    bool found = false;
 230
 231    for (unsigned int i = 0; i < MAX_SAMPLERS; i++) {
 232       found |= key_debug(brw, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE",
 233                          old_key->swizzles[i], key->swizzles[i]);
 234    }
 235    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 1st coordinate",
 236                       old_key->gl_clamp_mask[0], key->gl_clamp_mask[0]);
 237    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 2nd coordinate",
 238                       old_key->gl_clamp_mask[1], key->gl_clamp_mask[1]);
 239    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 3rd coordinate",
 240                       old_key->gl_clamp_mask[2], key->gl_clamp_mask[2]);
 241    found |= key_debug(brw, "GL_MESA_ycbcr texturing\n",
 242                       old_key->yuvtex_mask, key->yuvtex_mask);
 243    found |= key_debug(brw, "GL_MESA_ycbcr UV swapping\n",
 244                       old_key->yuvtex_swap_mask, key->yuvtex_swap_mask);
 245    found |= key_debug(brw, "gather channel quirk on any texture unit",
 246                       old_key->gather_channel_quirk_mask, key->gather_channel_quirk_mask);
 247
 248    return found;
 249 }
 250
 251 void
 252 brw_wm_debug_recompile(struct brw_context *brw,
 253                        struct gl_shader_program *prog,
 254                        const struct brw_wm_prog_key *key)
 255 {
 256    struct brw_cache_item *c = NULL;
 257    const struct brw_wm_prog_key *old_key = NULL;
 258    bool found = false;
 259
 260    perf_debug("Recompiling fragment shader for program %d\n", prog->Name);
 261
 262    for (unsigned int i = 0; i < brw->cache.size; i++) {
 263       for (c = brw->cache.items[i]; c; c = c->next) {
 264          if (c->cache_id == BRW_WM_PROG) {
 265             old_key = c->key;
 266
 267             if (old_key->program_string_id == key->program_string_id)
 268                break;
 269          }
 270       }
 271       if (c)
 272          break;
 273    }
 274
 275    if (!c) {
 276       perf_debug("  Didn't find previous compile in the shader cache for debug\n");
 277       return;
 278    }
 279
 280    found |= key_debug(brw, "alphatest, computed depth, depth test, or "
 281                       "depth write",
 282                       old_key->iz_lookup, key->iz_lookup);
 283    found |= key_debug(brw, "depth statistics",
 284                       old_key->stats_wm, key->stats_wm);
 285    found |= key_debug(brw, "flat shading",
 286                       old_key->flat_shade, key->flat_shade);
 287    found |= key_debug(brw, "number of color buffers",
 288                       old_key->nr_color_regions, key->nr_color_regions);
 289    found |= key_debug(brw, "MRT alpha test or alpha-to-coverage",
 290                       old_key->replicate_alpha, key->replicate_alpha);
 291    found |= key_debug(brw, "rendering to FBO",
 292                       old_key->render_to_fbo, key->render_to_fbo);
 293    found |= key_debug(brw, "fragment color clamping",
 294                       old_key->clamp_fragment_color, key->clamp_fragment_color);
 295    found |= key_debug(brw, "line smoothing",
 296                       old_key->line_aa, key->line_aa);
 297    found |= key_debug(brw, "renderbuffer height",
 298                       old_key->drawable_height, key->drawable_height);
 299    found |= key_debug(brw, "input slots valid",
 300                       old_key->input_slots_valid, key->input_slots_valid);
 301    found |= key_debug(brw, "mrt alpha test function",
 302                       old_key->alpha_test_func, key->alpha_test_func);
 303    found |= key_debug(brw, "mrt alpha test reference value",
 304                       old_key->alpha_test_ref, key->alpha_test_ref);
 305
 306    found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex);
 307
 308    if (!found) {
 309       perf_debug("  Something else\n");
 310    }
 311 }
 312
 313 static uint8_t
 314 gen6_gather_workaround(GLenum internalformat)
 315 {
 316    switch (internalformat) {
 317       case GL_R8I: return WA_SIGN | WA_8BIT;
 318       case GL_R8UI: return WA_8BIT;
 319       case GL_R16I: return WA_SIGN | WA_16BIT;
 320       case GL_R16UI: return WA_16BIT;
 321       /* note that even though GL_R32I and GL_R32UI have format overrides
 322        * in the surface state, there is no shader w/a required */
 323       default: return 0;
 324    }
 325 }
 326
 327 void
 328 brw_populate_sampler_prog_key_data(struct gl_context *ctx,
 329                                    const struct gl_program *prog,
 330                                    unsigned sampler_count,
 331                                    struct brw_sampler_prog_key_data *key)
 332 {
 333    struct brw_context *brw = brw_context(ctx);
 334
 335    for (int s = 0; s < sampler_count; s++) {
 336       key->swizzles[s] = SWIZZLE_NOOP;
 337
 338       if (!(prog->SamplersUsed & (1 << s)))
 339          continue;
 340
 341       int unit_id = prog->SamplerUnits[s];
 342       const struct gl_texture_unit *unit = &ctx->Texture.Unit[unit_id];
 343
 344       if (unit->_ReallyEnabled && unit->_Current->Target != GL_TEXTURE_BUFFER) {
 345          const struct gl_texture_object *t = unit->_Current;
 346          const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
 347          struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit_id);
 348
 349          const bool alpha_depth = t->DepthMode == GL_ALPHA &&
 350             (img->_BaseFormat == GL_DEPTH_COMPONENT ||
 351              img->_BaseFormat == GL_DEPTH_STENCIL);
 352
 353          /* Haswell handles texture swizzling as surface format overrides
 354           * (except for GL_ALPHA); all other platforms need MOVs in the shader.
 355           */
 356          if (alpha_depth || (brw->gen < 8 && !brw->is_haswell))
 357             key->swizzles[s] = brw_get_texture_swizzle(ctx, t);
 358
 359          if (img->InternalFormat == GL_YCBCR_MESA) {
 360             key->yuvtex_mask |= 1 << s;
 361             if (img->TexFormat == MESA_FORMAT_YCBCR)
 362                 key->yuvtex_swap_mask |= 1 << s;
 363          }
 364
 365          if (sampler->MinFilter != GL_NEAREST &&
 366              sampler->MagFilter != GL_NEAREST) {
 367             if (sampler->WrapS == GL_CLAMP)
 368                key->gl_clamp_mask[0] |= 1 << s;
 369             if (sampler->WrapT == GL_CLAMP)
 370                key->gl_clamp_mask[1] |= 1 << s;
 371             if (sampler->WrapR == GL_CLAMP)
 372                key->gl_clamp_mask[2] |= 1 << s;
 373          }
 374
 375          /* gather4's channel select for green from RG32F is broken;
 376           * requires a shader w/a on IVB; fixable with just SCS on HSW. */
 377          if (brw->gen == 7 && !brw->is_haswell && prog->UsesGather) {
 378             if (img->InternalFormat == GL_RG32F)
 379                key->gather_channel_quirk_mask |= 1 << s;
 380          }
 381
 382          /* Gen6's gather4 is broken for UINT/SINT; we treat them as
 383           * UNORM/FLOAT instead and fix it in the shader.
 384           */
 385          if (brw->gen == 6 && prog->UsesGather) {
 386             key->gen6_gather_wa[s] = gen6_gather_workaround(img->InternalFormat);
 387          }
 388
 389          /* If this is a multisample sampler, and uses the CMS MSAA layout,
 390           * then we need to emit slightly different code to first sample the
 391           * MCS surface.
 392           */
 393          struct intel_texture_object *intel_tex =
 394             intel_texture_object((struct gl_texture_object *)t);
 395
 396          if (brw->gen >= 7 &&
 397              intel_tex->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) {
 398             key->compressed_multisample_layout_mask |= 1 << s;
 399          }
 400       }
 401    }
 402 }
 403
 404 static void brw_wm_populate_key( struct brw_context *brw,
 405                                  struct brw_wm_prog_key *key )
 406 {
 407    struct gl_context *ctx = &brw->ctx;
 408    /* BRW_NEW_FRAGMENT_PROGRAM */
 409    const struct brw_fragment_program *fp =
 410       (struct brw_fragment_program *)brw->fragment_program;
 411    const struct gl_program *prog = (struct gl_program *) brw->fragment_program;
 412    GLuint lookup = 0;
 413    GLuint line_aa;
 414    bool program_uses_dfdy = fp->program.UsesDFdy;
 415    bool multisample_fbo = ctx->DrawBuffer->Visual.samples > 1;
 416
 417    memset(key, 0, sizeof(*key));
 418
 419    /* Build the index for table lookup
 420     */
 421    if (brw->gen < 6) {
 422       /* _NEW_COLOR */
 423       if (fp->program.UsesKill || ctx->Color.AlphaEnabled)
 424          lookup |= IZ_PS_KILL_ALPHATEST_BIT;
 425
 426       if (fp->program.Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
 427          lookup |= IZ_PS_COMPUTES_DEPTH_BIT;
 428
 429       /* _NEW_DEPTH */
 430       if (ctx->Depth.Test)
 431          lookup |= IZ_DEPTH_TEST_ENABLE_BIT;
 432
 433       if (ctx->Depth.Test && ctx->Depth.Mask) /* ?? */
 434          lookup |= IZ_DEPTH_WRITE_ENABLE_BIT;
 435
 436       /* _NEW_STENCIL | _NEW_BUFFERS */
 437       if (ctx->Stencil._Enabled) {
 438          lookup |= IZ_STENCIL_TEST_ENABLE_BIT;
 439
 440          if (ctx->Stencil.WriteMask[0] ||
 441              ctx->Stencil.WriteMask[ctx->Stencil._BackFace])
 442             lookup |= IZ_STENCIL_WRITE_ENABLE_BIT;
 443       }
 444       key->iz_lookup = lookup;
 445    }
 446
 447    line_aa = AA_NEVER;
 448
 449    /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
 450    if (ctx->Line.SmoothFlag) {
 451       if (brw->reduced_primitive == GL_LINES) {
 452          line_aa = AA_ALWAYS;
 453       }
 454       else if (brw->reduced_primitive == GL_TRIANGLES) {
 455          if (ctx->Polygon.FrontMode == GL_LINE) {
 456             line_aa = AA_SOMETIMES;
 457
 458             if (ctx->Polygon.BackMode == GL_LINE ||
 459                 (ctx->Polygon.CullFlag &&
 460                  ctx->Polygon.CullFaceMode == GL_BACK))
 461                line_aa = AA_ALWAYS;
 462          }
 463          else if (ctx->Polygon.BackMode == GL_LINE) {
 464             line_aa = AA_SOMETIMES;
 465
 466             if ((ctx->Polygon.CullFlag &&
 467                  ctx->Polygon.CullFaceMode == GL_FRONT))
 468                line_aa = AA_ALWAYS;
 469          }
 470       }
 471    }
 472
 473    key->line_aa = line_aa;
 474
 475    /* _NEW_HINT */
 476    if (brw->disable_derivative_optimization) {
 477       key->high_quality_derivatives =
 478          ctx->Hint.FragmentShaderDerivative != GL_FASTEST;
 479    } else {
 480       key->high_quality_derivatives =
 481          ctx->Hint.FragmentShaderDerivative == GL_NICEST;
 482    }
 483
 484    if (brw->gen < 6)
 485       key->stats_wm = brw->stats_wm;
 486
 487    /* _NEW_LIGHT */
 488    key->flat_shade = (ctx->Light.ShadeModel == GL_FLAT);
 489
 490    /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */
 491    key->clamp_fragment_color = ctx->Color._ClampFragmentColor;
 492
 493    /* _NEW_TEXTURE */
 494    brw_populate_sampler_prog_key_data(ctx, prog, brw->wm.base.sampler_count,
 495                                       &key->tex);
 496
 497    /* _NEW_BUFFERS */
 498    /*
 499     * Include the draw buffer origin and height so that we can calculate
 500     * fragment position values relative to the bottom left of the drawable,
 501     * from the incoming screen origin relative position we get as part of our
 502     * payload.
 503     *
 504     * This is only needed for the WM_WPOSXY opcode when the fragment program
 505     * uses the gl_FragCoord input.
 506     *
 507     * We could avoid recompiling by including this as a constant referenced by
 508     * our program, but if we were to do that it would also be nice to handle
 509     * getting that constant updated at batchbuffer submit time (when we
 510     * hold the lock and know where the buffer really is) rather than at emit
 511     * time when we don't hold the lock and are just guessing.  We could also
 512     * just avoid using this as key data if the program doesn't use
 513     * fragment.position.
 514     *
 515     * For DRI2 the origin_x/y will always be (0,0) but we still need the
 516     * drawable height in order to invert the Y axis.
 517     */
 518    if (fp->program.Base.InputsRead & VARYING_BIT_POS) {
 519       key->drawable_height = ctx->DrawBuffer->Height;
 520    }
 521
 522    if ((fp->program.Base.InputsRead & VARYING_BIT_POS) || program_uses_dfdy) {
 523       key->render_to_fbo = _mesa_is_user_fbo(ctx->DrawBuffer);
 524    }
 525
 526    /* _NEW_BUFFERS */
 527    key->nr_color_regions = ctx->DrawBuffer->_NumColorDrawBuffers;
 528
 529    /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */
 530    key->replicate_alpha = ctx->DrawBuffer->_NumColorDrawBuffers > 1 &&
 531       (ctx->Multisample.SampleAlphaToCoverage || ctx->Color.AlphaEnabled);
 532
 533    /* _NEW_BUFFERS _NEW_MULTISAMPLE */
 534    /* Ignore sample qualifier while computing this flag. */
 535    key->persample_shading =
 536       _mesa_get_min_invocations_per_fragment(ctx, &fp->program, true) > 1;
 537
 538    key->compute_pos_offset =
 539       _mesa_get_min_invocations_per_fragment(ctx, &fp->program, false) > 1 &&
 540       fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_POS;
 541
 542    key->compute_sample_id =
 543       multisample_fbo &&
 544       ctx->Multisample.Enabled &&
 545       (fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_ID);
 546
 547    /* BRW_NEW_VUE_MAP_GEOM_OUT */
 548    if (brw->gen < 6 || _mesa_bitcount_64(fp->program.Base.InputsRead &
 549                                          BRW_FS_VARYING_INPUT_MASK) > 16)
 550       key->input_slots_valid = brw->vue_map_geom_out.slots_valid;
 551
 552
 553    /* _NEW_COLOR | _NEW_BUFFERS */
 554    /* Pre-gen6, the hardware alpha test always used each render
 555     * target's alpha to do alpha test, as opposed to render target 0's alpha
 556     * like GL requires.  Fix that by building the alpha test into the
 557     * shader, and we'll skip enabling the fixed function alpha test.
 558     */
 559    if (brw->gen < 6 && ctx->DrawBuffer->_NumColorDrawBuffers > 1 && ctx->Color.AlphaEnabled) {
 560       key->alpha_test_func = ctx->Color.AlphaFunc;
 561       key->alpha_test_ref = ctx->Color.AlphaRef;
 562    }
 563
 564    /* The unique fragment program ID */
 565    key->program_string_id = fp->id;
 566 }
 567
 568
 569 static void
 570 brw_upload_wm_prog(struct brw_context *brw)
 571 {
 572    struct gl_context *ctx = &brw->ctx;
 573    struct brw_wm_prog_key key;
 574    struct brw_fragment_program *fp = (struct brw_fragment_program *)
 575       brw->fragment_program;
 576
 577    brw_wm_populate_key(brw, &key);
 578
 579    if (!brw_search_cache(&brw->cache, BRW_WM_PROG,
 580                          &key, sizeof(key),
 581                          &brw->wm.base.prog_offset, &brw->wm.prog_data)) {
 582       bool success = do_wm_prog(brw, ctx->_Shader->_CurrentFragmentProgram, fp,
 583                                 &key);
 584       (void) success;
 585       assert(success);
 586    }
 587    brw->wm.base.prog_data = &brw->wm.prog_data->base;
 588 }
 589
 590
 591 const struct brw_tracked_state brw_wm_prog = {
 592    .dirty = {
 593       .mesa  = (_NEW_COLOR |
 594                 _NEW_DEPTH |
 595                 _NEW_STENCIL |
 596                 _NEW_POLYGON |
 597                 _NEW_LINE |
 598                 _NEW_HINT |
 599                 _NEW_LIGHT |
 600                 _NEW_FRAG_CLAMP |
 601                 _NEW_BUFFERS |
 602                 _NEW_TEXTURE |
 603                 _NEW_MULTISAMPLE),
 604       .brw   = (BRW_NEW_FRAGMENT_PROGRAM |
 605                 BRW_NEW_REDUCED_PRIMITIVE |
 606                 BRW_NEW_VUE_MAP_GEOM_OUT |
 607                 BRW_NEW_STATS_WM)
 608    },
 609    .emit = brw_upload_wm_prog
 610 };
 611