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