2 * Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 * Intel funded Tungsten Graphics to
4 * develop this 3D driver.
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:
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.
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.
26 #include "brw_context.h"
28 #include "brw_state.h"
29 #include "main/enums.h"
30 #include "main/formats.h"
31 #include "main/fbobject.h"
32 #include "main/samplerobj.h"
33 #include "main/framebuffer.h"
34 #include "program/prog_parameter.h"
35 #include "program/program.h"
36 #include "intel_mipmap_tree.h"
38 #include "util/ralloc.h"
41 * Return a bitfield where bit n is set if barycentric interpolation mode n
42 * (see enum brw_wm_barycentric_interp_mode) is needed by the fragment shader.
45 brw_compute_barycentric_interp_modes(struct brw_context
*brw
,
46 bool shade_model_flat
,
47 bool persample_shading
,
48 const struct gl_fragment_program
*fprog
)
50 unsigned barycentric_interp_modes
= 0;
53 /* Loop through all fragment shader inputs to figure out what interpolation
54 * modes are in use, and set the appropriate bits in
55 * barycentric_interp_modes.
57 for (attr
= 0; attr
< VARYING_SLOT_MAX
; ++attr
) {
58 enum glsl_interp_qualifier interp_qualifier
=
59 fprog
->InterpQualifier
[attr
];
60 bool is_centroid
= (fprog
->IsCentroid
& BITFIELD64_BIT(attr
)) &&
62 bool is_sample
= (fprog
->IsSample
& BITFIELD64_BIT(attr
)) ||
64 bool is_gl_Color
= attr
== VARYING_SLOT_COL0
|| attr
== VARYING_SLOT_COL1
;
66 /* Ignore unused inputs. */
67 if (!(fprog
->Base
.InputsRead
& BITFIELD64_BIT(attr
)))
70 /* Ignore WPOS and FACE, because they don't require interpolation. */
71 if (attr
== VARYING_SLOT_POS
|| attr
== VARYING_SLOT_FACE
)
74 /* Determine the set (or sets) of barycentric coordinates needed to
75 * interpolate this variable. Note that when
76 * brw->needs_unlit_centroid_workaround is set, centroid interpolation
77 * uses PIXEL interpolation for unlit pixels and CENTROID interpolation
78 * for lit pixels, so we need both sets of barycentric coordinates.
80 if (interp_qualifier
== INTERP_QUALIFIER_NOPERSPECTIVE
) {
82 barycentric_interp_modes
|=
83 1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC
;
84 } else if (is_sample
) {
85 barycentric_interp_modes
|=
86 1 << BRW_WM_NONPERSPECTIVE_SAMPLE_BARYCENTRIC
;
88 if ((!is_centroid
&& !is_sample
) ||
89 brw
->needs_unlit_centroid_workaround
) {
90 barycentric_interp_modes
|=
91 1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC
;
93 } else if (interp_qualifier
== INTERP_QUALIFIER_SMOOTH
||
94 (!(shade_model_flat
&& is_gl_Color
) &&
95 interp_qualifier
== INTERP_QUALIFIER_NONE
)) {
97 barycentric_interp_modes
|=
98 1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC
;
99 } else if (is_sample
) {
100 barycentric_interp_modes
|=
101 1 << BRW_WM_PERSPECTIVE_SAMPLE_BARYCENTRIC
;
103 if ((!is_centroid
&& !is_sample
) ||
104 brw
->needs_unlit_centroid_workaround
) {
105 barycentric_interp_modes
|=
106 1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC
;
111 return barycentric_interp_modes
;
115 computed_depth_mode(struct gl_fragment_program
*fp
)
117 if (fp
->Base
.OutputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
)) {
118 switch (fp
->FragDepthLayout
) {
119 case FRAG_DEPTH_LAYOUT_NONE
:
120 case FRAG_DEPTH_LAYOUT_ANY
:
121 return BRW_PSCDEPTH_ON
;
122 case FRAG_DEPTH_LAYOUT_GREATER
:
123 return BRW_PSCDEPTH_ON_GE
;
124 case FRAG_DEPTH_LAYOUT_LESS
:
125 return BRW_PSCDEPTH_ON_LE
;
126 case FRAG_DEPTH_LAYOUT_UNCHANGED
:
127 return BRW_PSCDEPTH_OFF
;
130 return BRW_PSCDEPTH_OFF
;
134 brw_wm_prog_data_compare(const void *in_a
, const void *in_b
)
136 const struct brw_wm_prog_data
*a
= in_a
;
137 const struct brw_wm_prog_data
*b
= in_b
;
139 /* Compare the base structure. */
140 if (!brw_stage_prog_data_compare(&a
->base
, &b
->base
))
143 /* Compare the rest of the structure. */
144 const unsigned offset
= sizeof(struct brw_stage_prog_data
);
145 if (memcmp(((char *) a
) + offset
, ((char *) b
) + offset
,
146 sizeof(struct brw_wm_prog_data
) - offset
))
153 * All Mesa program -> GPU code generation goes through this function.
154 * Depending on the instructions used (i.e. flow control instructions)
155 * we'll use one of two code generators.
158 brw_codegen_wm_prog(struct brw_context
*brw
,
159 struct gl_shader_program
*prog
,
160 struct brw_fragment_program
*fp
,
161 struct brw_wm_prog_key
*key
)
163 struct gl_context
*ctx
= &brw
->ctx
;
164 void *mem_ctx
= ralloc_context(NULL
);
165 struct brw_wm_prog_data prog_data
;
166 const GLuint
*program
;
167 struct gl_shader
*fs
= NULL
;
171 fs
= prog
->_LinkedShaders
[MESA_SHADER_FRAGMENT
];
173 memset(&prog_data
, 0, sizeof(prog_data
));
174 /* key->alpha_test_func means simulating alpha testing via discards,
175 * so the shader definitely kills pixels.
177 prog_data
.uses_kill
= fp
->program
.UsesKill
|| key
->alpha_test_func
;
178 prog_data
.uses_omask
=
179 fp
->program
.Base
.OutputsWritten
& BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK
);
180 prog_data
.computed_depth_mode
= computed_depth_mode(&fp
->program
);
182 /* Use ALT floating point mode for ARB programs so that 0^0 == 1. */
184 prog_data
.base
.use_alt_mode
= true;
186 /* Allocate the references to the uniforms that will end up in the
187 * prog_data associated with the compiled program, and which will be freed
188 * by the state cache.
192 param_count
= fs
->num_uniform_components
;
194 param_count
= fp
->program
.Base
.Parameters
->NumParameters
* 4;
196 /* The backend also sometimes adds params for texture size. */
197 param_count
+= 2 * ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxTextureImageUnits
;
198 prog_data
.base
.param
=
199 rzalloc_array(NULL
, const gl_constant_value
*, param_count
);
200 prog_data
.base
.pull_param
=
201 rzalloc_array(NULL
, const gl_constant_value
*, param_count
);
202 prog_data
.base
.nr_params
= param_count
;
204 prog_data
.barycentric_interp_modes
=
205 brw_compute_barycentric_interp_modes(brw
, key
->flat_shade
,
206 key
->persample_shading
,
209 program
= brw_wm_fs_emit(brw
, mem_ctx
, key
, &prog_data
,
210 &fp
->program
, prog
, &program_size
);
211 if (program
== NULL
) {
212 ralloc_free(mem_ctx
);
216 if (prog_data
.base
.total_scratch
) {
217 brw_get_scratch_bo(brw
, &brw
->wm
.base
.scratch_bo
,
218 prog_data
.base
.total_scratch
* brw
->max_wm_threads
);
221 if (unlikely(INTEL_DEBUG
& DEBUG_WM
))
222 fprintf(stderr
, "\n");
224 brw_upload_cache(&brw
->cache
, BRW_CACHE_FS_PROG
,
225 key
, sizeof(struct brw_wm_prog_key
),
226 program
, program_size
,
227 &prog_data
, sizeof(prog_data
),
228 &brw
->wm
.base
.prog_offset
, &brw
->wm
.prog_data
);
230 ralloc_free(mem_ctx
);
236 key_debug(struct brw_context
*brw
, const char *name
, int a
, int b
)
239 perf_debug(" %s %d->%d\n", name
, a
, b
);
247 brw_debug_recompile_sampler_key(struct brw_context
*brw
,
248 const struct brw_sampler_prog_key_data
*old_key
,
249 const struct brw_sampler_prog_key_data
*key
)
253 for (unsigned int i
= 0; i
< MAX_SAMPLERS
; i
++) {
254 found
|= key_debug(brw
, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE",
255 old_key
->swizzles
[i
], key
->swizzles
[i
]);
257 found
|= key_debug(brw
, "GL_CLAMP enabled on any texture unit's 1st coordinate",
258 old_key
->gl_clamp_mask
[0], key
->gl_clamp_mask
[0]);
259 found
|= key_debug(brw
, "GL_CLAMP enabled on any texture unit's 2nd coordinate",
260 old_key
->gl_clamp_mask
[1], key
->gl_clamp_mask
[1]);
261 found
|= key_debug(brw
, "GL_CLAMP enabled on any texture unit's 3rd coordinate",
262 old_key
->gl_clamp_mask
[2], key
->gl_clamp_mask
[2]);
263 found
|= key_debug(brw
, "gather channel quirk on any texture unit",
264 old_key
->gather_channel_quirk_mask
, key
->gather_channel_quirk_mask
);
265 found
|= key_debug(brw
, "compressed multisample layout",
266 old_key
->compressed_multisample_layout_mask
,
267 key
->compressed_multisample_layout_mask
);
269 for (unsigned int i
= 0; i
< MAX_SAMPLERS
; i
++) {
270 found
|= key_debug(brw
, "textureGather workarounds",
271 old_key
->gen6_gather_wa
[i
], key
->gen6_gather_wa
[i
]);
278 brw_wm_debug_recompile(struct brw_context
*brw
,
279 struct gl_shader_program
*prog
,
280 const struct brw_wm_prog_key
*key
)
282 struct brw_cache_item
*c
= NULL
;
283 const struct brw_wm_prog_key
*old_key
= NULL
;
286 perf_debug("Recompiling fragment shader for program %d\n", prog
->Name
);
288 for (unsigned int i
= 0; i
< brw
->cache
.size
; i
++) {
289 for (c
= brw
->cache
.items
[i
]; c
; c
= c
->next
) {
290 if (c
->cache_id
== BRW_CACHE_FS_PROG
) {
293 if (old_key
->program_string_id
== key
->program_string_id
)
302 perf_debug(" Didn't find previous compile in the shader cache for debug\n");
306 found
|= key_debug(brw
, "alphatest, computed depth, depth test, or "
308 old_key
->iz_lookup
, key
->iz_lookup
);
309 found
|= key_debug(brw
, "depth statistics",
310 old_key
->stats_wm
, key
->stats_wm
);
311 found
|= key_debug(brw
, "flat shading",
312 old_key
->flat_shade
, key
->flat_shade
);
313 found
|= key_debug(brw
, "per-sample shading",
314 old_key
->persample_shading
, key
->persample_shading
);
315 found
|= key_debug(brw
, "per-sample shading and 2x MSAA",
316 old_key
->persample_2x
, key
->persample_2x
);
317 found
|= key_debug(brw
, "number of color buffers",
318 old_key
->nr_color_regions
, key
->nr_color_regions
);
319 found
|= key_debug(brw
, "MRT alpha test or alpha-to-coverage",
320 old_key
->replicate_alpha
, key
->replicate_alpha
);
321 found
|= key_debug(brw
, "rendering to FBO",
322 old_key
->render_to_fbo
, key
->render_to_fbo
);
323 found
|= key_debug(brw
, "fragment color clamping",
324 old_key
->clamp_fragment_color
, key
->clamp_fragment_color
);
325 found
|= key_debug(brw
, "line smoothing",
326 old_key
->line_aa
, key
->line_aa
);
327 found
|= key_debug(brw
, "renderbuffer height",
328 old_key
->drawable_height
, key
->drawable_height
);
329 found
|= key_debug(brw
, "input slots valid",
330 old_key
->input_slots_valid
, key
->input_slots_valid
);
331 found
|= key_debug(brw
, "mrt alpha test function",
332 old_key
->alpha_test_func
, key
->alpha_test_func
);
333 found
|= key_debug(brw
, "mrt alpha test reference value",
334 old_key
->alpha_test_ref
, key
->alpha_test_ref
);
336 found
|= brw_debug_recompile_sampler_key(brw
, &old_key
->tex
, &key
->tex
);
339 perf_debug(" Something else\n");
344 gen6_gather_workaround(GLenum internalformat
)
346 switch (internalformat
) {
347 case GL_R8I
: return WA_SIGN
| WA_8BIT
;
348 case GL_R8UI
: return WA_8BIT
;
349 case GL_R16I
: return WA_SIGN
| WA_16BIT
;
350 case GL_R16UI
: return WA_16BIT
;
352 /* Note that even though GL_R32I and GL_R32UI have format overrides in
353 * the surface state, there is no shader w/a required.
360 brw_populate_sampler_prog_key_data(struct gl_context
*ctx
,
361 const struct gl_program
*prog
,
362 unsigned sampler_count
,
363 struct brw_sampler_prog_key_data
*key
)
365 struct brw_context
*brw
= brw_context(ctx
);
367 for (int s
= 0; s
< sampler_count
; s
++) {
368 key
->swizzles
[s
] = SWIZZLE_NOOP
;
370 if (!(prog
->SamplersUsed
& (1 << s
)))
373 int unit_id
= prog
->SamplerUnits
[s
];
374 const struct gl_texture_unit
*unit
= &ctx
->Texture
.Unit
[unit_id
];
376 if (unit
->_Current
&& unit
->_Current
->Target
!= GL_TEXTURE_BUFFER
) {
377 const struct gl_texture_object
*t
= unit
->_Current
;
378 const struct gl_texture_image
*img
= t
->Image
[0][t
->BaseLevel
];
379 struct gl_sampler_object
*sampler
= _mesa_get_samplerobj(ctx
, unit_id
);
381 const bool alpha_depth
= t
->DepthMode
== GL_ALPHA
&&
382 (img
->_BaseFormat
== GL_DEPTH_COMPONENT
||
383 img
->_BaseFormat
== GL_DEPTH_STENCIL
);
385 /* Haswell handles texture swizzling as surface format overrides
386 * (except for GL_ALPHA); all other platforms need MOVs in the shader.
388 if (alpha_depth
|| (brw
->gen
< 8 && !brw
->is_haswell
))
389 key
->swizzles
[s
] = brw_get_texture_swizzle(ctx
, t
);
392 sampler
->MinFilter
!= GL_NEAREST
&&
393 sampler
->MagFilter
!= GL_NEAREST
) {
394 if (sampler
->WrapS
== GL_CLAMP
)
395 key
->gl_clamp_mask
[0] |= 1 << s
;
396 if (sampler
->WrapT
== GL_CLAMP
)
397 key
->gl_clamp_mask
[1] |= 1 << s
;
398 if (sampler
->WrapR
== GL_CLAMP
)
399 key
->gl_clamp_mask
[2] |= 1 << s
;
402 /* gather4's channel select for green from RG32F is broken; requires
403 * a shader w/a on IVB; fixable with just SCS on HSW.
405 if (brw
->gen
== 7 && !brw
->is_haswell
&& prog
->UsesGather
) {
406 if (img
->InternalFormat
== GL_RG32F
)
407 key
->gather_channel_quirk_mask
|= 1 << s
;
410 /* Gen6's gather4 is broken for UINT/SINT; we treat them as
411 * UNORM/FLOAT instead and fix it in the shader.
413 if (brw
->gen
== 6 && prog
->UsesGather
) {
414 key
->gen6_gather_wa
[s
] = gen6_gather_workaround(img
->InternalFormat
);
417 /* If this is a multisample sampler, and uses the CMS MSAA layout,
418 * then we need to emit slightly different code to first sample the
421 struct intel_texture_object
*intel_tex
=
422 intel_texture_object((struct gl_texture_object
*)t
);
425 intel_tex
->mt
->msaa_layout
== INTEL_MSAA_LAYOUT_CMS
) {
426 key
->compressed_multisample_layout_mask
|= 1 << s
;
433 brw_wm_state_dirty (struct brw_context
*brw
)
435 return brw_state_dirty(brw
,
447 BRW_NEW_FRAGMENT_PROGRAM
|
448 BRW_NEW_REDUCED_PRIMITIVE
|
450 BRW_NEW_VUE_MAP_GEOM_OUT
);
454 brw_wm_populate_key(struct brw_context
*brw
, struct brw_wm_prog_key
*key
)
456 struct gl_context
*ctx
= &brw
->ctx
;
457 /* BRW_NEW_FRAGMENT_PROGRAM */
458 const struct brw_fragment_program
*fp
=
459 (struct brw_fragment_program
*) brw
->fragment_program
;
460 const struct gl_program
*prog
= (struct gl_program
*) brw
->fragment_program
;
463 bool program_uses_dfdy
= fp
->program
.UsesDFdy
;
464 const bool multisample_fbo
= _mesa_geometric_samples(ctx
->DrawBuffer
) > 1;
466 memset(key
, 0, sizeof(*key
));
468 /* Build the index for table lookup
472 if (fp
->program
.UsesKill
|| ctx
->Color
.AlphaEnabled
)
473 lookup
|= IZ_PS_KILL_ALPHATEST_BIT
;
475 if (fp
->program
.Base
.OutputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
))
476 lookup
|= IZ_PS_COMPUTES_DEPTH_BIT
;
480 lookup
|= IZ_DEPTH_TEST_ENABLE_BIT
;
482 if (ctx
->Depth
.Test
&& ctx
->Depth
.Mask
) /* ?? */
483 lookup
|= IZ_DEPTH_WRITE_ENABLE_BIT
;
485 /* _NEW_STENCIL | _NEW_BUFFERS */
486 if (ctx
->Stencil
._Enabled
) {
487 lookup
|= IZ_STENCIL_TEST_ENABLE_BIT
;
489 if (ctx
->Stencil
.WriteMask
[0] ||
490 ctx
->Stencil
.WriteMask
[ctx
->Stencil
._BackFace
])
491 lookup
|= IZ_STENCIL_WRITE_ENABLE_BIT
;
493 key
->iz_lookup
= lookup
;
498 /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
499 if (ctx
->Line
.SmoothFlag
) {
500 if (brw
->reduced_primitive
== GL_LINES
) {
503 else if (brw
->reduced_primitive
== GL_TRIANGLES
) {
504 if (ctx
->Polygon
.FrontMode
== GL_LINE
) {
505 line_aa
= AA_SOMETIMES
;
507 if (ctx
->Polygon
.BackMode
== GL_LINE
||
508 (ctx
->Polygon
.CullFlag
&&
509 ctx
->Polygon
.CullFaceMode
== GL_BACK
))
512 else if (ctx
->Polygon
.BackMode
== GL_LINE
) {
513 line_aa
= AA_SOMETIMES
;
515 if ((ctx
->Polygon
.CullFlag
&&
516 ctx
->Polygon
.CullFaceMode
== GL_FRONT
))
522 key
->line_aa
= line_aa
;
525 key
->high_quality_derivatives
=
526 ctx
->Hint
.FragmentShaderDerivative
== GL_NICEST
;
529 key
->stats_wm
= brw
->stats_wm
;
532 key
->flat_shade
= (ctx
->Light
.ShadeModel
== GL_FLAT
);
534 /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */
535 key
->clamp_fragment_color
= ctx
->Color
._ClampFragmentColor
;
538 brw_populate_sampler_prog_key_data(ctx
, prog
, brw
->wm
.base
.sampler_count
,
543 * Include the draw buffer origin and height so that we can calculate
544 * fragment position values relative to the bottom left of the drawable,
545 * from the incoming screen origin relative position we get as part of our
548 * This is only needed for the WM_WPOSXY opcode when the fragment program
549 * uses the gl_FragCoord input.
551 * We could avoid recompiling by including this as a constant referenced by
552 * our program, but if we were to do that it would also be nice to handle
553 * getting that constant updated at batchbuffer submit time (when we
554 * hold the lock and know where the buffer really is) rather than at emit
555 * time when we don't hold the lock and are just guessing. We could also
556 * just avoid using this as key data if the program doesn't use
559 * For DRI2 the origin_x/y will always be (0,0) but we still need the
560 * drawable height in order to invert the Y axis.
562 if (fp
->program
.Base
.InputsRead
& VARYING_BIT_POS
) {
563 key
->drawable_height
= _mesa_geometric_height(ctx
->DrawBuffer
);
566 if ((fp
->program
.Base
.InputsRead
& VARYING_BIT_POS
) || program_uses_dfdy
) {
567 key
->render_to_fbo
= _mesa_is_user_fbo(ctx
->DrawBuffer
);
571 key
->nr_color_regions
= ctx
->DrawBuffer
->_NumColorDrawBuffers
;
573 /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */
574 key
->replicate_alpha
= ctx
->DrawBuffer
->_NumColorDrawBuffers
> 1 &&
575 (ctx
->Multisample
.SampleAlphaToCoverage
|| ctx
->Color
.AlphaEnabled
);
577 /* _NEW_BUFFERS _NEW_MULTISAMPLE */
578 /* Ignore sample qualifier while computing this flag. */
579 key
->persample_shading
=
580 _mesa_get_min_invocations_per_fragment(ctx
, &fp
->program
, true) > 1;
581 if (key
->persample_shading
)
582 key
->persample_2x
= _mesa_geometric_samples(ctx
->DrawBuffer
) == 2;
584 key
->compute_pos_offset
=
585 _mesa_get_min_invocations_per_fragment(ctx
, &fp
->program
, false) > 1 &&
586 fp
->program
.Base
.SystemValuesRead
& SYSTEM_BIT_SAMPLE_POS
;
588 key
->compute_sample_id
=
590 ctx
->Multisample
.Enabled
&&
591 (fp
->program
.Base
.SystemValuesRead
& SYSTEM_BIT_SAMPLE_ID
);
593 /* BRW_NEW_VUE_MAP_GEOM_OUT */
594 if (brw
->gen
< 6 || _mesa_bitcount_64(fp
->program
.Base
.InputsRead
&
595 BRW_FS_VARYING_INPUT_MASK
) > 16)
596 key
->input_slots_valid
= brw
->vue_map_geom_out
.slots_valid
;
599 /* _NEW_COLOR | _NEW_BUFFERS */
600 /* Pre-gen6, the hardware alpha test always used each render
601 * target's alpha to do alpha test, as opposed to render target 0's alpha
602 * like GL requires. Fix that by building the alpha test into the
603 * shader, and we'll skip enabling the fixed function alpha test.
605 if (brw
->gen
< 6 && ctx
->DrawBuffer
->_NumColorDrawBuffers
> 1 &&
606 ctx
->Color
.AlphaEnabled
) {
607 key
->alpha_test_func
= ctx
->Color
.AlphaFunc
;
608 key
->alpha_test_ref
= ctx
->Color
.AlphaRef
;
611 /* The unique fragment program ID */
612 key
->program_string_id
= fp
->id
;
616 brw_upload_wm_prog(struct brw_context
*brw
)
618 struct gl_context
*ctx
= &brw
->ctx
;
619 struct gl_shader_program
*current
= ctx
->_Shader
->_CurrentFragmentProgram
;
620 struct brw_wm_prog_key key
;
621 struct brw_fragment_program
*fp
= (struct brw_fragment_program
*)
622 brw
->fragment_program
;
624 if (!brw_wm_state_dirty(brw
))
627 brw_wm_populate_key(brw
, &key
);
629 if (!brw_search_cache(&brw
->cache
, BRW_CACHE_FS_PROG
,
631 &brw
->wm
.base
.prog_offset
, &brw
->wm
.prog_data
)) {
632 bool success
= brw_codegen_wm_prog(brw
, current
, fp
, &key
);
636 brw
->wm
.base
.prog_data
= &brw
->wm
.prog_data
->base
;