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 **********************************************************************/
29 * Keith Whitwell <keithw@vmware.com>
32 #include "brw_context.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"
43 #include "glsl/ralloc.h"
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.
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
)
55 unsigned barycentric_interp_modes
= 0;
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.
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 bool is_sample
= (fprog
->IsSample
& BITFIELD64_BIT(attr
)) ||
68 bool is_gl_Color
= attr
== VARYING_SLOT_COL0
|| attr
== VARYING_SLOT_COL1
;
70 /* Ignore unused inputs. */
71 if (!(fprog
->Base
.InputsRead
& BITFIELD64_BIT(attr
)))
74 /* Ignore WPOS and FACE, because they don't require interpolation. */
75 if (attr
== VARYING_SLOT_POS
|| attr
== VARYING_SLOT_FACE
)
78 /* Determine the set (or sets) of barycentric coordinates needed to
79 * interpolate this variable. Note that when
80 * brw->needs_unlit_centroid_workaround is set, centroid interpolation
81 * uses PIXEL interpolation for unlit pixels and CENTROID interpolation
82 * for lit pixels, so we need both sets of barycentric coordinates.
84 if (interp_qualifier
== INTERP_QUALIFIER_NOPERSPECTIVE
) {
86 barycentric_interp_modes
|=
87 1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC
;
88 } else if (is_sample
) {
89 barycentric_interp_modes
|=
90 1 << BRW_WM_NONPERSPECTIVE_SAMPLE_BARYCENTRIC
;
92 if ((!is_centroid
&& !is_sample
) ||
93 brw
->needs_unlit_centroid_workaround
) {
94 barycentric_interp_modes
|=
95 1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC
;
97 } else if (interp_qualifier
== INTERP_QUALIFIER_SMOOTH
||
98 (!(shade_model_flat
&& is_gl_Color
) &&
99 interp_qualifier
== INTERP_QUALIFIER_NONE
)) {
101 barycentric_interp_modes
|=
102 1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC
;
103 } else if (is_sample
) {
104 barycentric_interp_modes
|=
105 1 << BRW_WM_PERSPECTIVE_SAMPLE_BARYCENTRIC
;
107 if ((!is_centroid
&& !is_sample
) ||
108 brw
->needs_unlit_centroid_workaround
) {
109 barycentric_interp_modes
|=
110 1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC
;
115 return barycentric_interp_modes
;
119 brw_wm_prog_data_compare(const void *in_a
, const void *in_b
)
121 const struct brw_wm_prog_data
*a
= in_a
;
122 const struct brw_wm_prog_data
*b
= in_b
;
124 /* Compare all the struct (including the base) up to the pointers. */
125 if (memcmp(a
, b
, offsetof(struct brw_wm_prog_data
, param
)))
128 if (memcmp(a
->param
, b
->param
, a
->nr_params
* sizeof(void *)))
131 if (memcmp(a
->pull_param
, b
->pull_param
, a
->nr_pull_params
* sizeof(void *)))
138 brw_wm_prog_data_free(const void *in_prog_data
)
140 const struct brw_wm_prog_data
*prog_data
= in_prog_data
;
142 ralloc_free((void *)prog_data
->param
);
143 ralloc_free((void *)prog_data
->pull_param
);
147 * All Mesa program -> GPU code generation goes through this function.
148 * Depending on the instructions used (i.e. flow control instructions)
149 * we'll use one of two code generators.
151 bool do_wm_prog(struct brw_context
*brw
,
152 struct gl_shader_program
*prog
,
153 struct brw_fragment_program
*fp
,
154 struct brw_wm_prog_key
*key
)
156 struct brw_wm_compile
*c
;
157 const GLuint
*program
;
158 struct gl_shader
*fs
= NULL
;
162 fs
= prog
->_LinkedShaders
[MESA_SHADER_FRAGMENT
];
164 c
= rzalloc(NULL
, struct brw_wm_compile
);
166 /* Allocate the references to the uniforms that will end up in the
167 * prog_data associated with the compiled program, and which will be freed
168 * by the state cache.
172 param_count
= fs
->num_uniform_components
;
174 param_count
= fp
->program
.Base
.Parameters
->NumParameters
* 4;
176 /* The backend also sometimes adds params for texture size. */
177 param_count
+= 2 * BRW_MAX_TEX_UNIT
;
178 c
->prog_data
.param
= rzalloc_array(NULL
, const float *, param_count
);
179 c
->prog_data
.pull_param
= rzalloc_array(NULL
, const float *, param_count
);
181 memcpy(&c
->key
, key
, sizeof(*key
));
183 c
->prog_data
.barycentric_interp_modes
=
184 brw_compute_barycentric_interp_modes(brw
, c
->key
.flat_shade
,
185 c
->key
.persample_shading
,
188 program
= brw_wm_fs_emit(brw
, c
, &fp
->program
, prog
, &program_size
);
192 /* Scratch space is used for register spilling */
193 if (c
->last_scratch
) {
194 perf_debug("Fragment shader triggered register spilling. "
195 "Try reducing the number of live scalar values to "
196 "improve performance.\n");
198 c
->prog_data
.total_scratch
= brw_get_scratch_size(c
->last_scratch
);
200 brw_get_scratch_bo(brw
, &brw
->wm
.base
.scratch_bo
,
201 c
->prog_data
.total_scratch
* brw
->max_wm_threads
);
204 if (unlikely(INTEL_DEBUG
& DEBUG_WM
))
205 fprintf(stderr
, "\n");
207 brw_upload_cache(&brw
->cache
, BRW_WM_PROG
,
208 &c
->key
, sizeof(c
->key
),
209 program
, program_size
,
210 &c
->prog_data
, sizeof(c
->prog_data
),
211 &brw
->wm
.base
.prog_offset
, &brw
->wm
.prog_data
);
219 key_debug(struct brw_context
*brw
, const char *name
, int a
, int b
)
222 perf_debug(" %s %d->%d\n", name
, a
, b
);
230 brw_debug_recompile_sampler_key(struct brw_context
*brw
,
231 const struct brw_sampler_prog_key_data
*old_key
,
232 const struct brw_sampler_prog_key_data
*key
)
236 for (unsigned int i
= 0; i
< MAX_SAMPLERS
; i
++) {
237 found
|= key_debug(brw
, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE",
238 old_key
->swizzles
[i
], key
->swizzles
[i
]);
240 found
|= key_debug(brw
, "GL_CLAMP enabled on any texture unit's 1st coordinate",
241 old_key
->gl_clamp_mask
[0], key
->gl_clamp_mask
[0]);
242 found
|= key_debug(brw
, "GL_CLAMP enabled on any texture unit's 2nd coordinate",
243 old_key
->gl_clamp_mask
[1], key
->gl_clamp_mask
[1]);
244 found
|= key_debug(brw
, "GL_CLAMP enabled on any texture unit's 3rd coordinate",
245 old_key
->gl_clamp_mask
[2], key
->gl_clamp_mask
[2]);
246 found
|= key_debug(brw
, "GL_MESA_ycbcr texturing\n",
247 old_key
->yuvtex_mask
, key
->yuvtex_mask
);
248 found
|= key_debug(brw
, "GL_MESA_ycbcr UV swapping\n",
249 old_key
->yuvtex_swap_mask
, key
->yuvtex_swap_mask
);
250 found
|= key_debug(brw
, "gather channel quirk on any texture unit",
251 old_key
->gather_channel_quirk_mask
, key
->gather_channel_quirk_mask
);
257 brw_wm_debug_recompile(struct brw_context
*brw
,
258 struct gl_shader_program
*prog
,
259 const struct brw_wm_prog_key
*key
)
261 struct brw_cache_item
*c
= NULL
;
262 const struct brw_wm_prog_key
*old_key
= NULL
;
265 perf_debug("Recompiling fragment shader for program %d\n", prog
->Name
);
267 for (unsigned int i
= 0; i
< brw
->cache
.size
; i
++) {
268 for (c
= brw
->cache
.items
[i
]; c
; c
= c
->next
) {
269 if (c
->cache_id
== BRW_WM_PROG
) {
272 if (old_key
->program_string_id
== key
->program_string_id
)
281 perf_debug(" Didn't find previous compile in the shader cache for debug\n");
285 found
|= key_debug(brw
, "alphatest, computed depth, depth test, or "
287 old_key
->iz_lookup
, key
->iz_lookup
);
288 found
|= key_debug(brw
, "depth statistics",
289 old_key
->stats_wm
, key
->stats_wm
);
290 found
|= key_debug(brw
, "flat shading",
291 old_key
->flat_shade
, key
->flat_shade
);
292 found
|= key_debug(brw
, "number of color buffers",
293 old_key
->nr_color_regions
, key
->nr_color_regions
);
294 found
|= key_debug(brw
, "MRT alpha test or alpha-to-coverage",
295 old_key
->replicate_alpha
, key
->replicate_alpha
);
296 found
|= key_debug(brw
, "rendering to FBO",
297 old_key
->render_to_fbo
, key
->render_to_fbo
);
298 found
|= key_debug(brw
, "fragment color clamping",
299 old_key
->clamp_fragment_color
, key
->clamp_fragment_color
);
300 found
|= key_debug(brw
, "line smoothing",
301 old_key
->line_aa
, key
->line_aa
);
302 found
|= key_debug(brw
, "renderbuffer height",
303 old_key
->drawable_height
, key
->drawable_height
);
304 found
|= key_debug(brw
, "input slots valid",
305 old_key
->input_slots_valid
, key
->input_slots_valid
);
306 found
|= key_debug(brw
, "mrt alpha test function",
307 old_key
->alpha_test_func
, key
->alpha_test_func
);
308 found
|= key_debug(brw
, "mrt alpha test reference value",
309 old_key
->alpha_test_ref
, key
->alpha_test_ref
);
311 found
|= brw_debug_recompile_sampler_key(brw
, &old_key
->tex
, &key
->tex
);
314 perf_debug(" Something else\n");
319 brw_populate_sampler_prog_key_data(struct gl_context
*ctx
,
320 const struct gl_program
*prog
,
321 unsigned sampler_count
,
322 struct brw_sampler_prog_key_data
*key
)
324 struct brw_context
*brw
= brw_context(ctx
);
326 for (int s
= 0; s
< sampler_count
; s
++) {
327 key
->swizzles
[s
] = SWIZZLE_NOOP
;
329 if (!(prog
->SamplersUsed
& (1 << s
)))
332 int unit_id
= prog
->SamplerUnits
[s
];
333 const struct gl_texture_unit
*unit
= &ctx
->Texture
.Unit
[unit_id
];
335 if (unit
->_ReallyEnabled
&& unit
->_Current
->Target
!= GL_TEXTURE_BUFFER
) {
336 const struct gl_texture_object
*t
= unit
->_Current
;
337 const struct gl_texture_image
*img
= t
->Image
[0][t
->BaseLevel
];
338 struct gl_sampler_object
*sampler
= _mesa_get_samplerobj(ctx
, unit_id
);
340 const bool alpha_depth
= t
->DepthMode
== GL_ALPHA
&&
341 (img
->_BaseFormat
== GL_DEPTH_COMPONENT
||
342 img
->_BaseFormat
== GL_DEPTH_STENCIL
);
344 /* Haswell handles texture swizzling as surface format overrides
345 * (except for GL_ALPHA); all other platforms need MOVs in the shader.
347 if (alpha_depth
|| (brw
->gen
< 8 && !brw
->is_haswell
))
348 key
->swizzles
[s
] = brw_get_texture_swizzle(ctx
, t
);
350 if (img
->InternalFormat
== GL_YCBCR_MESA
) {
351 key
->yuvtex_mask
|= 1 << s
;
352 if (img
->TexFormat
== MESA_FORMAT_YCBCR
)
353 key
->yuvtex_swap_mask
|= 1 << s
;
356 if (sampler
->MinFilter
!= GL_NEAREST
&&
357 sampler
->MagFilter
!= GL_NEAREST
) {
358 if (sampler
->WrapS
== GL_CLAMP
)
359 key
->gl_clamp_mask
[0] |= 1 << s
;
360 if (sampler
->WrapT
== GL_CLAMP
)
361 key
->gl_clamp_mask
[1] |= 1 << s
;
362 if (sampler
->WrapR
== GL_CLAMP
)
363 key
->gl_clamp_mask
[2] |= 1 << s
;
366 /* gather4's channel select for green from RG32F is broken;
367 * requires a shader w/a on IVB; fixable with just SCS on HSW. */
368 if (brw
->gen
== 7 && !brw
->is_haswell
&& prog
->UsesGather
) {
369 if (img
->InternalFormat
== GL_RG32F
)
370 key
->gather_channel_quirk_mask
|= 1 << s
;
373 /* If this is a multisample sampler, and uses the CMS MSAA layout,
374 * then we need to emit slightly different code to first sample the
377 struct intel_texture_object
*intel_tex
=
378 intel_texture_object((struct gl_texture_object
*)t
);
381 intel_tex
->mt
->msaa_layout
== INTEL_MSAA_LAYOUT_CMS
) {
382 key
->compressed_multisample_layout_mask
|= 1 << s
;
388 static void brw_wm_populate_key( struct brw_context
*brw
,
389 struct brw_wm_prog_key
*key
)
391 struct gl_context
*ctx
= &brw
->ctx
;
392 /* BRW_NEW_FRAGMENT_PROGRAM */
393 const struct brw_fragment_program
*fp
=
394 (struct brw_fragment_program
*)brw
->fragment_program
;
395 const struct gl_program
*prog
= (struct gl_program
*) brw
->fragment_program
;
398 bool program_uses_dfdy
= fp
->program
.UsesDFdy
;
399 bool multisample_fbo
= ctx
->DrawBuffer
->Visual
.samples
> 1;
401 memset(key
, 0, sizeof(*key
));
403 /* Build the index for table lookup
407 if (fp
->program
.UsesKill
|| ctx
->Color
.AlphaEnabled
)
408 lookup
|= IZ_PS_KILL_ALPHATEST_BIT
;
410 if (fp
->program
.Base
.OutputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
))
411 lookup
|= IZ_PS_COMPUTES_DEPTH_BIT
;
415 lookup
|= IZ_DEPTH_TEST_ENABLE_BIT
;
417 if (ctx
->Depth
.Test
&& ctx
->Depth
.Mask
) /* ?? */
418 lookup
|= IZ_DEPTH_WRITE_ENABLE_BIT
;
420 /* _NEW_STENCIL | _NEW_BUFFERS */
421 if (ctx
->Stencil
._Enabled
) {
422 lookup
|= IZ_STENCIL_TEST_ENABLE_BIT
;
424 if (ctx
->Stencil
.WriteMask
[0] ||
425 ctx
->Stencil
.WriteMask
[ctx
->Stencil
._BackFace
])
426 lookup
|= IZ_STENCIL_WRITE_ENABLE_BIT
;
428 key
->iz_lookup
= lookup
;
433 /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
434 if (ctx
->Line
.SmoothFlag
) {
435 if (brw
->reduced_primitive
== GL_LINES
) {
438 else if (brw
->reduced_primitive
== GL_TRIANGLES
) {
439 if (ctx
->Polygon
.FrontMode
== GL_LINE
) {
440 line_aa
= AA_SOMETIMES
;
442 if (ctx
->Polygon
.BackMode
== GL_LINE
||
443 (ctx
->Polygon
.CullFlag
&&
444 ctx
->Polygon
.CullFaceMode
== GL_BACK
))
447 else if (ctx
->Polygon
.BackMode
== GL_LINE
) {
448 line_aa
= AA_SOMETIMES
;
450 if ((ctx
->Polygon
.CullFlag
&&
451 ctx
->Polygon
.CullFaceMode
== GL_FRONT
))
457 key
->line_aa
= line_aa
;
460 if (brw
->disable_derivative_optimization
) {
461 key
->high_quality_derivatives
=
462 ctx
->Hint
.FragmentShaderDerivative
!= GL_FASTEST
;
464 key
->high_quality_derivatives
=
465 ctx
->Hint
.FragmentShaderDerivative
== GL_NICEST
;
469 key
->stats_wm
= brw
->stats_wm
;
472 key
->flat_shade
= (ctx
->Light
.ShadeModel
== GL_FLAT
);
474 /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */
475 key
->clamp_fragment_color
= ctx
->Color
._ClampFragmentColor
;
478 brw_populate_sampler_prog_key_data(ctx
, prog
, brw
->wm
.base
.sampler_count
,
483 * Include the draw buffer origin and height so that we can calculate
484 * fragment position values relative to the bottom left of the drawable,
485 * from the incoming screen origin relative position we get as part of our
488 * This is only needed for the WM_WPOSXY opcode when the fragment program
489 * uses the gl_FragCoord input.
491 * We could avoid recompiling by including this as a constant referenced by
492 * our program, but if we were to do that it would also be nice to handle
493 * getting that constant updated at batchbuffer submit time (when we
494 * hold the lock and know where the buffer really is) rather than at emit
495 * time when we don't hold the lock and are just guessing. We could also
496 * just avoid using this as key data if the program doesn't use
499 * For DRI2 the origin_x/y will always be (0,0) but we still need the
500 * drawable height in order to invert the Y axis.
502 if (fp
->program
.Base
.InputsRead
& VARYING_BIT_POS
) {
503 key
->drawable_height
= ctx
->DrawBuffer
->Height
;
506 if ((fp
->program
.Base
.InputsRead
& VARYING_BIT_POS
) || program_uses_dfdy
) {
507 key
->render_to_fbo
= _mesa_is_user_fbo(ctx
->DrawBuffer
);
511 key
->nr_color_regions
= ctx
->DrawBuffer
->_NumColorDrawBuffers
;
513 /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */
514 key
->replicate_alpha
= ctx
->DrawBuffer
->_NumColorDrawBuffers
> 1 &&
515 (ctx
->Multisample
.SampleAlphaToCoverage
|| ctx
->Color
.AlphaEnabled
);
517 /* _NEW_BUFFERS _NEW_MULTISAMPLE */
518 /* Ignore sample qualifier while computing this flag. */
519 key
->persample_shading
=
520 _mesa_get_min_invocations_per_fragment(ctx
, &fp
->program
, true) > 1;
522 key
->compute_pos_offset
=
523 _mesa_get_min_invocations_per_fragment(ctx
, &fp
->program
, false) > 1 &&
524 fp
->program
.Base
.SystemValuesRead
& SYSTEM_BIT_SAMPLE_POS
;
526 key
->compute_sample_id
=
528 ctx
->Multisample
.Enabled
&&
529 (fp
->program
.Base
.SystemValuesRead
& SYSTEM_BIT_SAMPLE_ID
);
531 /* BRW_NEW_VUE_MAP_GEOM_OUT */
532 if (brw
->gen
< 6 || _mesa_bitcount_64(fp
->program
.Base
.InputsRead
&
533 BRW_FS_VARYING_INPUT_MASK
) > 16)
534 key
->input_slots_valid
= brw
->vue_map_geom_out
.slots_valid
;
537 /* _NEW_COLOR | _NEW_BUFFERS */
538 /* Pre-gen6, the hardware alpha test always used each render
539 * target's alpha to do alpha test, as opposed to render target 0's alpha
540 * like GL requires. Fix that by building the alpha test into the
541 * shader, and we'll skip enabling the fixed function alpha test.
543 if (brw
->gen
< 6 && ctx
->DrawBuffer
->_NumColorDrawBuffers
> 1 && ctx
->Color
.AlphaEnabled
) {
544 key
->alpha_test_func
= ctx
->Color
.AlphaFunc
;
545 key
->alpha_test_ref
= ctx
->Color
.AlphaRef
;
548 /* The unique fragment program ID */
549 key
->program_string_id
= fp
->id
;
554 brw_upload_wm_prog(struct brw_context
*brw
)
556 struct gl_context
*ctx
= &brw
->ctx
;
557 struct brw_wm_prog_key key
;
558 struct brw_fragment_program
*fp
= (struct brw_fragment_program
*)
559 brw
->fragment_program
;
561 brw_wm_populate_key(brw
, &key
);
563 if (!brw_search_cache(&brw
->cache
, BRW_WM_PROG
,
565 &brw
->wm
.base
.prog_offset
, &brw
->wm
.prog_data
)) {
566 bool success
= do_wm_prog(brw
, ctx
->Shader
._CurrentFragmentProgram
, fp
,
571 brw
->wm
.base
.prog_data
= &brw
->wm
.prog_data
->base
;
575 const struct brw_tracked_state brw_wm_prog
= {
577 .mesa
= (_NEW_COLOR
|
588 .brw
= (BRW_NEW_FRAGMENT_PROGRAM
|
589 BRW_NEW_REDUCED_PRIMITIVE
|
590 BRW_NEW_VUE_MAP_GEOM_OUT
|
593 .emit
= brw_upload_wm_prog