Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 1 | /* |
Ian Romanick | 2b81cef | 2015-06-10 17:09:16 -0700 | [diff] [blame] | 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 | */ |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 26 | #include "brw_context.h" |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 27 | #include "brw_wm.h" |
| 28 | #include "brw_state.h" |
Chris Forbes | cfa3c8a | 2013-08-11 09:55:30 +1200 | [diff] [blame] | 29 | #include "main/enums.h" |
Eric Anholt | c374487 | 2010-08-10 22:21:59 -0700 | [diff] [blame] | 30 | #include "main/formats.h" |
Brian Paul | 4433b03 | 2012-04-20 07:58:59 -0600 | [diff] [blame] | 31 | #include "main/fbobject.h" |
Eric Anholt | 1f32c66 | 2011-04-20 11:48:31 -0700 | [diff] [blame] | 32 | #include "main/samplerobj.h" |
Kevin Rogovin | 41b6db2 | 2015-06-17 13:29:55 +0300 | [diff] [blame] | 33 | #include "main/framebuffer.h" |
Eric Anholt | 8752764 | 2011-05-16 15:10:26 -0700 | [diff] [blame] | 34 | #include "program/prog_parameter.h" |
Anuj Phogat | 65d0452 | 2013-10-24 15:53:05 -0700 | [diff] [blame] | 35 | #include "program/program.h" |
Chris Forbes | 27359b8 | 2013-11-30 10:01:12 +1300 | [diff] [blame] | 36 | #include "intel_mipmap_tree.h" |
Kristian Høgsberg Kristensen | 654e950 | 2016-05-01 21:22:54 -0700 | [diff] [blame] | 37 | #include "intel_image.h" |
Jason Ekstrand | 700bebb | 2017-02-28 09:10:43 -0800 | [diff] [blame] | 38 | #include "compiler/brw_nir.h" |
Matt Turner | ecac1aa | 2015-11-22 15:30:59 -0800 | [diff] [blame] | 39 | #include "brw_program.h" |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 40 | |
Kenneth Graunke | 1e0da62 | 2014-02-24 23:39:14 -0800 | [diff] [blame] | 41 | #include "util/ralloc.h" |
Kenneth Graunke | 774fb90 | 2011-05-16 11:49:57 -0700 | [diff] [blame] | 42 | |
Jason Ekstrand | ea006c4 | 2015-10-01 08:55:20 -0700 | [diff] [blame] | 43 | static void |
Jason Ekstrand | 527f371 | 2016-08-22 15:01:08 -0700 | [diff] [blame] | 44 | assign_fs_binding_table_offsets(const struct gen_device_info *devinfo, |
Jason Ekstrand | ea006c4 | 2015-10-01 08:55:20 -0700 | [diff] [blame] | 45 | const struct gl_program *prog, |
| 46 | const struct brw_wm_prog_key *key, |
| 47 | struct brw_wm_prog_data *prog_data) |
| 48 | { |
| 49 | uint32_t next_binding_table_offset = 0; |
| 50 | |
| 51 | /* If there are no color regions, we still perform an FB write to a null |
| 52 | * renderbuffer, which we place at surface index 0. |
| 53 | */ |
| 54 | prog_data->binding_table.render_target_start = next_binding_table_offset; |
| 55 | next_binding_table_offset += MAX2(key->nr_color_regions, 1); |
| 56 | |
Francisco Jerez | 08705ba | 2016-07-01 13:46:40 -0700 | [diff] [blame] | 57 | next_binding_table_offset = |
Timothy Arceri | 9ca14f5 | 2016-11-05 09:34:52 +1100 | [diff] [blame] | 58 | brw_assign_common_binding_table_offsets(devinfo, prog, &prog_data->base, |
Francisco Jerez | 08705ba | 2016-07-01 13:46:40 -0700 | [diff] [blame] | 59 | next_binding_table_offset); |
| 60 | |
Jason Ekstrand | b86dba8 | 2017-05-08 09:20:21 -0700 | [diff] [blame] | 61 | if (prog->nir->info.outputs_read && !key->coherent_fb_fetch) { |
Francisco Jerez | 08705ba | 2016-07-01 13:46:40 -0700 | [diff] [blame] | 62 | prog_data->binding_table.render_target_read_start = |
| 63 | next_binding_table_offset; |
| 64 | next_binding_table_offset += key->nr_color_regions; |
| 65 | } |
Jason Ekstrand | ea006c4 | 2015-10-01 08:55:20 -0700 | [diff] [blame] | 66 | } |
| 67 | |
Timothy Arceri | 6f76ca3 | 2016-11-04 14:09:35 +1100 | [diff] [blame] | 68 | static void |
| 69 | brw_wm_debug_recompile(struct brw_context *brw, struct gl_program *prog, |
| 70 | const struct brw_wm_prog_key *key) |
| 71 | { |
Timothy Arceri | 6f76ca3 | 2016-11-04 14:09:35 +1100 | [diff] [blame] | 72 | perf_debug("Recompiling fragment shader for program %d\n", prog->Id); |
| 73 | |
Kenneth Graunke | f9edc55 | 2016-11-11 13:31:06 -0800 | [diff] [blame] | 74 | bool found = false; |
| 75 | const struct brw_wm_prog_key *old_key = |
| 76 | brw_find_previous_compile(&brw->cache, BRW_CACHE_FS_PROG, |
| 77 | key->program_string_id); |
Timothy Arceri | 6f76ca3 | 2016-11-04 14:09:35 +1100 | [diff] [blame] | 78 | |
Kenneth Graunke | f9edc55 | 2016-11-11 13:31:06 -0800 | [diff] [blame] | 79 | if (!old_key) { |
Timothy Arceri | 6f76ca3 | 2016-11-04 14:09:35 +1100 | [diff] [blame] | 80 | perf_debug(" Didn't find previous compile in the shader cache for debug\n"); |
| 81 | return; |
| 82 | } |
| 83 | |
| 84 | found |= key_debug(brw, "alphatest, computed depth, depth test, or " |
| 85 | "depth write", |
| 86 | old_key->iz_lookup, key->iz_lookup); |
| 87 | found |= key_debug(brw, "depth statistics", |
| 88 | old_key->stats_wm, key->stats_wm); |
| 89 | found |= key_debug(brw, "flat shading", |
| 90 | old_key->flat_shade, key->flat_shade); |
| 91 | found |= key_debug(brw, "per-sample interpolation", |
| 92 | old_key->persample_interp, key->persample_interp); |
| 93 | found |= key_debug(brw, "number of color buffers", |
| 94 | old_key->nr_color_regions, key->nr_color_regions); |
| 95 | found |= key_debug(brw, "MRT alpha test or alpha-to-coverage", |
| 96 | old_key->replicate_alpha, key->replicate_alpha); |
| 97 | found |= key_debug(brw, "fragment color clamping", |
| 98 | old_key->clamp_fragment_color, key->clamp_fragment_color); |
| 99 | found |= key_debug(brw, "multisampled FBO", |
| 100 | old_key->multisample_fbo, key->multisample_fbo); |
| 101 | found |= key_debug(brw, "line smoothing", |
| 102 | old_key->line_aa, key->line_aa); |
| 103 | found |= key_debug(brw, "input slots valid", |
| 104 | old_key->input_slots_valid, key->input_slots_valid); |
| 105 | found |= key_debug(brw, "mrt alpha test function", |
| 106 | old_key->alpha_test_func, key->alpha_test_func); |
| 107 | found |= key_debug(brw, "mrt alpha test reference value", |
| 108 | old_key->alpha_test_ref, key->alpha_test_ref); |
Kenneth Graunke | 244c2a5 | 2017-06-14 01:52:04 -0700 | [diff] [blame] | 109 | found |= key_debug(brw, "force dual color blending", |
| 110 | old_key->force_dual_color_blend, |
| 111 | key->force_dual_color_blend); |
Timothy Arceri | 6f76ca3 | 2016-11-04 14:09:35 +1100 | [diff] [blame] | 112 | |
| 113 | found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex); |
| 114 | |
| 115 | if (!found) { |
| 116 | perf_debug(" Something else\n"); |
| 117 | } |
| 118 | } |
| 119 | |
Brian Paul | 2f78d4a | 2009-02-12 15:35:41 -0700 | [diff] [blame] | 120 | /** |
| 121 | * All Mesa program -> GPU code generation goes through this function. |
| 122 | * Depending on the instructions used (i.e. flow control instructions) |
| 123 | * we'll use one of two code generators. |
| 124 | */ |
Timothy Arceri | 6e3f609 | 2016-11-04 16:04:01 +1100 | [diff] [blame] | 125 | static bool |
Jason Ekstrand | a85c4c9 | 2015-04-16 11:06:57 -0700 | [diff] [blame] | 126 | brw_codegen_wm_prog(struct brw_context *brw, |
Timothy Arceri | 13d0cf5 | 2016-10-18 16:17:14 +1100 | [diff] [blame] | 127 | struct brw_program *fp, |
Timothy Arceri | 91d61fb | 2016-10-20 09:59:00 +1100 | [diff] [blame] | 128 | struct brw_wm_prog_key *key, |
| 129 | struct brw_vue_map *vue_map) |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 130 | { |
Lionel Landwerlin | 94d0e7d | 2016-09-23 00:41:23 +0300 | [diff] [blame] | 131 | const struct gen_device_info *devinfo = &brw->screen->devinfo; |
Kenneth Graunke | 5a51a26 | 2014-01-18 14:48:11 -0800 | [diff] [blame] | 132 | struct gl_context *ctx = &brw->ctx; |
Kenneth Graunke | 2d4ac9b | 2014-05-14 01:21:02 -0700 | [diff] [blame] | 133 | void *mem_ctx = ralloc_context(NULL); |
Kenneth Graunke | 09b4f26 | 2014-05-14 01:35:30 -0700 | [diff] [blame] | 134 | struct brw_wm_prog_data prog_data; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 135 | const GLuint *program; |
| 136 | GLuint program_size; |
Kristian Høgsberg Kristensen | a548c75 | 2015-09-04 17:09:40 -0700 | [diff] [blame] | 137 | bool start_busy = false; |
| 138 | double start_time = 0; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 139 | |
Kenneth Graunke | 09b4f26 | 2014-05-14 01:35:30 -0700 | [diff] [blame] | 140 | memset(&prog_data, 0, sizeof(prog_data)); |
Francisco Jerez | 786e085 | 2015-02-09 21:04:53 +0200 | [diff] [blame] | 141 | |
Kenneth Graunke | 7b6620f | 2014-11-30 01:35:14 -0800 | [diff] [blame] | 142 | /* Use ALT floating point mode for ARB programs so that 0^0 == 1. */ |
Timothy Arceri | 2384868 | 2016-11-09 23:44:39 +1100 | [diff] [blame] | 143 | if (fp->program.is_arb_asm) |
Kenneth Graunke | 7b6620f | 2014-11-30 01:35:14 -0800 | [diff] [blame] | 144 | prog_data.base.use_alt_mode = true; |
| 145 | |
Timothy Arceri | 9ca14f5 | 2016-11-05 09:34:52 +1100 | [diff] [blame] | 146 | assign_fs_binding_table_offsets(devinfo, &fp->program, key, &prog_data); |
Jason Ekstrand | ea006c4 | 2015-10-01 08:55:20 -0700 | [diff] [blame] | 147 | |
Eric Anholt | f144b78 | 2012-08-26 21:19:05 -0700 | [diff] [blame] | 148 | /* Allocate the references to the uniforms that will end up in the |
| 149 | * prog_data associated with the compiled program, and which will be freed |
| 150 | * by the state cache. |
| 151 | */ |
Timothy Arceri | 3423488 | 2016-10-19 13:23:37 +1100 | [diff] [blame] | 152 | int param_count = fp->program.nir->num_uniforms / 4; |
Timothy Arceri | ba40c8b | 2016-10-27 15:59:46 +1100 | [diff] [blame] | 153 | prog_data.base.nr_image_params = fp->program.info.num_images; |
Eric Anholt | a43b107 | 2012-11-08 14:02:22 -0800 | [diff] [blame] | 154 | /* The backend also sometimes adds params for texture size. */ |
Kenneth Graunke | 5a51a26 | 2014-01-18 14:48:11 -0800 | [diff] [blame] | 155 | param_count += 2 * ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits; |
Neil Roberts | 2c50212 | 2014-08-11 12:21:44 +0100 | [diff] [blame] | 156 | prog_data.base.param = |
| 157 | rzalloc_array(NULL, const gl_constant_value *, param_count); |
Kenneth Graunke | 09b4f26 | 2014-05-14 01:35:30 -0700 | [diff] [blame] | 158 | prog_data.base.pull_param = |
Neil Roberts | 2c50212 | 2014-08-11 12:21:44 +0100 | [diff] [blame] | 159 | rzalloc_array(NULL, const gl_constant_value *, param_count); |
Francisco Jerez | 87a3e02 | 2015-01-21 17:34:49 +0200 | [diff] [blame] | 160 | prog_data.base.image_param = |
| 161 | rzalloc_array(NULL, struct brw_image_param, |
| 162 | prog_data.base.nr_image_params); |
Kenneth Graunke | 09b4f26 | 2014-05-14 01:35:30 -0700 | [diff] [blame] | 163 | prog_data.base.nr_params = param_count; |
Eric Anholt | f144b78 | 2012-08-26 21:19:05 -0700 | [diff] [blame] | 164 | |
Timothy Arceri | 2384868 | 2016-11-09 23:44:39 +1100 | [diff] [blame] | 165 | if (!fp->program.is_arb_asm) { |
Timothy Arceri | 2a4d169 | 2016-11-07 20:54:45 +1100 | [diff] [blame] | 166 | brw_nir_setup_glsl_uniforms(fp->program.nir, &fp->program, |
Jason Ekstrand | 30c6357 | 2015-09-30 17:01:03 -0700 | [diff] [blame] | 167 | &prog_data.base, true); |
| 168 | } else { |
Timothy Arceri | 3423488 | 2016-10-19 13:23:37 +1100 | [diff] [blame] | 169 | brw_nir_setup_arb_uniforms(fp->program.nir, &fp->program, |
Jason Ekstrand | 30c6357 | 2015-09-30 17:01:03 -0700 | [diff] [blame] | 170 | &prog_data.base); |
Timothy Arceri | c3b8bf9 | 2016-11-03 21:47:04 +1100 | [diff] [blame] | 171 | |
| 172 | if (unlikely(INTEL_DEBUG & DEBUG_WM)) |
| 173 | brw_dump_arb_asm("fragment", &fp->program); |
Jason Ekstrand | 30c6357 | 2015-09-30 17:01:03 -0700 | [diff] [blame] | 174 | } |
| 175 | |
Kristian Høgsberg Kristensen | a548c75 | 2015-09-04 17:09:40 -0700 | [diff] [blame] | 176 | if (unlikely(brw->perf_debug)) { |
| 177 | start_busy = (brw->batch.last_bo && |
Kenneth Graunke | d30a927 | 2017-04-03 20:13:08 -0700 | [diff] [blame] | 178 | brw_bo_busy(brw->batch.last_bo)); |
Kristian Høgsberg Kristensen | a548c75 | 2015-09-04 17:09:40 -0700 | [diff] [blame] | 179 | start_time = get_time(); |
| 180 | } |
| 181 | |
Kristian Høgsberg Kristensen | ee0f010 | 2015-10-07 05:06:30 -0700 | [diff] [blame] | 182 | int st_index8 = -1, st_index16 = -1; |
| 183 | if (INTEL_DEBUG & DEBUG_SHADER_TIME) { |
Timothy Arceri | 6643da6 | 2016-12-20 21:37:23 +1100 | [diff] [blame] | 184 | st_index8 = brw_get_shader_time_index(brw, &fp->program, ST_FS8, |
Timothy Arceri | 2384868 | 2016-11-09 23:44:39 +1100 | [diff] [blame] | 185 | !fp->program.is_arb_asm); |
Timothy Arceri | 6643da6 | 2016-12-20 21:37:23 +1100 | [diff] [blame] | 186 | st_index16 = brw_get_shader_time_index(brw, &fp->program, ST_FS16, |
Timothy Arceri | 2384868 | 2016-11-09 23:44:39 +1100 | [diff] [blame] | 187 | !fp->program.is_arb_asm); |
Kristian Høgsberg Kristensen | ee0f010 | 2015-10-07 05:06:30 -0700 | [diff] [blame] | 188 | } |
| 189 | |
Jason Ekstrand | 22ad449 | 2015-10-05 19:27:28 -0700 | [diff] [blame] | 190 | char *error_str = NULL; |
Kenneth Graunke | 9694b23 | 2015-11-30 15:47:13 -0800 | [diff] [blame] | 191 | program = brw_compile_fs(brw->screen->compiler, brw, mem_ctx, |
Timothy Arceri | 3423488 | 2016-10-19 13:23:37 +1100 | [diff] [blame] | 192 | key, &prog_data, fp->program.nir, |
| 193 | &fp->program, st_index8, st_index16, |
Jason Ekstrand | ea225d4 | 2017-06-03 15:20:32 -0700 | [diff] [blame] | 194 | true, false, vue_map, |
Jason Ekstrand | 265487a | 2016-05-16 14:30:25 -0700 | [diff] [blame] | 195 | &program_size, &error_str); |
Timothy Arceri | 91d61fb | 2016-10-20 09:59:00 +1100 | [diff] [blame] | 196 | |
Kenneth Graunke | 81b11bf | 2014-05-14 01:04:02 -0700 | [diff] [blame] | 197 | if (program == NULL) { |
Timothy Arceri | 2384868 | 2016-11-09 23:44:39 +1100 | [diff] [blame] | 198 | if (!fp->program.is_arb_asm) { |
Timothy Arceri | a3fd8bb | 2017-02-04 10:46:53 +1100 | [diff] [blame] | 199 | fp->program.sh.data->LinkStatus = linking_failure; |
Timothy Arceri | b880281 | 2016-11-08 10:25:57 +1100 | [diff] [blame] | 200 | ralloc_strcat(&fp->program.sh.data->InfoLog, error_str); |
Jason Ekstrand | 22ad449 | 2015-10-05 19:27:28 -0700 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | _mesa_problem(NULL, "Failed to compile fragment shader: %s\n", error_str); |
| 204 | |
Kenneth Graunke | 2d4ac9b | 2014-05-14 01:21:02 -0700 | [diff] [blame] | 205 | ralloc_free(mem_ctx); |
Kenneth Graunke | 4d09fe9 | 2012-11-20 16:21:27 -0800 | [diff] [blame] | 206 | return false; |
Kenneth Graunke | 81b11bf | 2014-05-14 01:04:02 -0700 | [diff] [blame] | 207 | } |
Brian Paul | 2f78d4a | 2009-02-12 15:35:41 -0700 | [diff] [blame] | 208 | |
Timothy Arceri | 718a0cf | 2016-11-04 13:37:21 +1100 | [diff] [blame] | 209 | if (unlikely(brw->perf_debug)) { |
| 210 | if (fp->compiled_once) |
Timothy Arceri | 6f76ca3 | 2016-11-04 14:09:35 +1100 | [diff] [blame] | 211 | brw_wm_debug_recompile(brw, &fp->program, key); |
Timothy Arceri | 718a0cf | 2016-11-04 13:37:21 +1100 | [diff] [blame] | 212 | fp->compiled_once = true; |
Kristian Høgsberg Kristensen | a548c75 | 2015-09-04 17:09:40 -0700 | [diff] [blame] | 213 | |
Kenneth Graunke | d30a927 | 2017-04-03 20:13:08 -0700 | [diff] [blame] | 214 | if (start_busy && !brw_bo_busy(brw->batch.last_bo)) { |
Kristian Høgsberg Kristensen | a548c75 | 2015-09-04 17:09:40 -0700 | [diff] [blame] | 215 | perf_debug("FS compile took %.03f ms and stalled the GPU\n", |
| 216 | (get_time() - start_time) * 1000); |
| 217 | } |
| 218 | } |
| 219 | |
Francisco Jerez | d960284 | 2016-06-13 14:56:22 -0700 | [diff] [blame] | 220 | brw_alloc_stage_scratch(brw, &brw->wm.base, |
| 221 | prog_data.base.total_scratch, |
Lionel Landwerlin | 94d0e7d | 2016-09-23 00:41:23 +0300 | [diff] [blame] | 222 | devinfo->max_wm_threads); |
Eric Anholt | 4e72525 | 2010-10-21 15:07:45 -0700 | [diff] [blame] | 223 | |
Timothy Arceri | 2384868 | 2016-11-09 23:44:39 +1100 | [diff] [blame] | 224 | if (unlikely((INTEL_DEBUG & DEBUG_WM) && fp->program.is_arb_asm)) |
Eric Anholt | fc3971d | 2009-01-08 19:15:04 -0800 | [diff] [blame] | 225 | fprintf(stderr, "\n"); |
| 226 | |
Kenneth Graunke | 67c4980 | 2014-09-26 11:38:06 -0700 | [diff] [blame] | 227 | brw_upload_cache(&brw->cache, BRW_CACHE_FS_PROG, |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 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.base.prog_data); |
Eric Anholt | 8752764 | 2011-05-16 15:10:26 -0700 | [diff] [blame] | 232 | |
Kenneth Graunke | 2d4ac9b | 2014-05-14 01:21:02 -0700 | [diff] [blame] | 233 | ralloc_free(mem_ctx); |
Eric Anholt | 2fcaf4e | 2012-11-06 09:48:51 -0800 | [diff] [blame] | 234 | |
Eric Anholt | 8752764 | 2011-05-16 15:10:26 -0700 | [diff] [blame] | 235 | return true; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 236 | } |
| 237 | |
Eric Anholt | fc3b7c9 | 2012-07-12 13:19:53 -0700 | [diff] [blame] | 238 | bool |
Kenneth Graunke | ca43757 | 2013-07-02 23:17:14 -0700 | [diff] [blame] | 239 | brw_debug_recompile_sampler_key(struct brw_context *brw, |
Eric Anholt | 14cec07 | 2013-02-22 13:15:20 -0800 | [diff] [blame] | 240 | const struct brw_sampler_prog_key_data *old_key, |
Eric Anholt | fc3b7c9 | 2012-07-12 13:19:53 -0700 | [diff] [blame] | 241 | const struct brw_sampler_prog_key_data *key) |
| 242 | { |
| 243 | bool found = false; |
| 244 | |
Kenneth Graunke | f3d0daf | 2012-08-26 00:28:38 -0700 | [diff] [blame] | 245 | for (unsigned int i = 0; i < MAX_SAMPLERS; i++) { |
Kenneth Graunke | ca43757 | 2013-07-02 23:17:14 -0700 | [diff] [blame] | 246 | found |= key_debug(brw, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE", |
Kenneth Graunke | 98211d5 | 2012-08-15 16:35:35 -0700 | [diff] [blame] | 247 | old_key->swizzles[i], key->swizzles[i]); |
Eric Anholt | fc3b7c9 | 2012-07-12 13:19:53 -0700 | [diff] [blame] | 248 | } |
Kenneth Graunke | ca43757 | 2013-07-02 23:17:14 -0700 | [diff] [blame] | 249 | found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 1st coordinate", |
Kenneth Graunke | 98211d5 | 2012-08-15 16:35:35 -0700 | [diff] [blame] | 250 | old_key->gl_clamp_mask[0], key->gl_clamp_mask[0]); |
Kenneth Graunke | ca43757 | 2013-07-02 23:17:14 -0700 | [diff] [blame] | 251 | found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 2nd coordinate", |
Kenneth Graunke | 98211d5 | 2012-08-15 16:35:35 -0700 | [diff] [blame] | 252 | old_key->gl_clamp_mask[1], key->gl_clamp_mask[1]); |
Kenneth Graunke | ca43757 | 2013-07-02 23:17:14 -0700 | [diff] [blame] | 253 | found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 3rd coordinate", |
Kenneth Graunke | 98211d5 | 2012-08-15 16:35:35 -0700 | [diff] [blame] | 254 | old_key->gl_clamp_mask[2], key->gl_clamp_mask[2]); |
Chris Forbes | cfa3c8a | 2013-08-11 09:55:30 +1200 | [diff] [blame] | 255 | found |= key_debug(brw, "gather channel quirk on any texture unit", |
| 256 | old_key->gather_channel_quirk_mask, key->gather_channel_quirk_mask); |
Kenneth Graunke | 30c8d8a | 2015-04-23 23:17:10 -0700 | [diff] [blame] | 257 | found |= key_debug(brw, "compressed multisample layout", |
| 258 | old_key->compressed_multisample_layout_mask, |
| 259 | key->compressed_multisample_layout_mask); |
Neil Roberts | 1a97cac | 2015-09-15 16:34:35 +0100 | [diff] [blame] | 260 | found |= key_debug(brw, "16x msaa", |
| 261 | old_key->msaa_16, |
| 262 | key->msaa_16); |
Kenneth Graunke | 30c8d8a | 2015-04-23 23:17:10 -0700 | [diff] [blame] | 263 | |
Kristian Høgsberg Kristensen | 654e950 | 2016-05-01 21:22:54 -0700 | [diff] [blame] | 264 | found |= key_debug(brw, "y_uv image bound", |
| 265 | old_key->y_uv_image_mask, |
| 266 | key->y_uv_image_mask); |
| 267 | found |= key_debug(brw, "y_u_v image bound", |
| 268 | old_key->y_u_v_image_mask, |
| 269 | key->y_u_v_image_mask); |
| 270 | found |= key_debug(brw, "yx_xuxv image bound", |
| 271 | old_key->yx_xuxv_image_mask, |
| 272 | key->yx_xuxv_image_mask); |
Johnson Lin | 165e704 | 2017-06-16 13:51:34 +0800 | [diff] [blame^] | 273 | found |= key_debug(brw, "xy_uxvx image bound", |
| 274 | old_key->xy_uxvx_image_mask, |
| 275 | key->xy_uxvx_image_mask); |
| 276 | |
Kristian Høgsberg Kristensen | 654e950 | 2016-05-01 21:22:54 -0700 | [diff] [blame] | 277 | |
Kenneth Graunke | 30c8d8a | 2015-04-23 23:17:10 -0700 | [diff] [blame] | 278 | for (unsigned int i = 0; i < MAX_SAMPLERS; i++) { |
| 279 | found |= key_debug(brw, "textureGather workarounds", |
| 280 | old_key->gen6_gather_wa[i], key->gen6_gather_wa[i]); |
| 281 | } |
Eric Anholt | fc3b7c9 | 2012-07-12 13:19:53 -0700 | [diff] [blame] | 282 | |
| 283 | return found; |
| 284 | } |
| 285 | |
Chris Forbes | 2b7bbd8 | 2014-02-03 22:13:03 +1300 | [diff] [blame] | 286 | static uint8_t |
| 287 | gen6_gather_workaround(GLenum internalformat) |
| 288 | { |
| 289 | switch (internalformat) { |
Ian Romanick | 2b81cef | 2015-06-10 17:09:16 -0700 | [diff] [blame] | 290 | case GL_R8I: return WA_SIGN | WA_8BIT; |
| 291 | case GL_R8UI: return WA_8BIT; |
| 292 | case GL_R16I: return WA_SIGN | WA_16BIT; |
| 293 | case GL_R16UI: return WA_16BIT; |
| 294 | default: |
| 295 | /* Note that even though GL_R32I and GL_R32UI have format overrides in |
| 296 | * the surface state, there is no shader w/a required. |
| 297 | */ |
| 298 | return 0; |
Chris Forbes | 2b7bbd8 | 2014-02-03 22:13:03 +1300 | [diff] [blame] | 299 | } |
| 300 | } |
| 301 | |
Kenneth Graunke | 1b05fc7 | 2011-12-06 15:36:21 -0800 | [diff] [blame] | 302 | void |
| 303 | brw_populate_sampler_prog_key_data(struct gl_context *ctx, |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 304 | const struct gl_program *prog, |
| 305 | struct brw_sampler_prog_key_data *key) |
Kenneth Graunke | 1b05fc7 | 2011-12-06 15:36:21 -0800 | [diff] [blame] | 306 | { |
Kenneth Graunke | 794de2f | 2013-07-06 00:15:44 -0700 | [diff] [blame] | 307 | struct brw_context *brw = brw_context(ctx); |
Timothy Arceri | 8f1ca0e | 2016-07-05 17:02:46 +1000 | [diff] [blame] | 308 | GLbitfield mask = prog->SamplersUsed; |
Kenneth Graunke | 6d6aef7 | 2012-09-21 03:13:36 -0700 | [diff] [blame] | 309 | |
Timothy Arceri | 8f1ca0e | 2016-07-05 17:02:46 +1000 | [diff] [blame] | 310 | while (mask) { |
| 311 | const int s = u_bit_scan(&mask); |
| 312 | |
Kenneth Graunke | f3d0daf | 2012-08-26 00:28:38 -0700 | [diff] [blame] | 313 | key->swizzles[s] = SWIZZLE_NOOP; |
Kenneth Graunke | 76d1301 | 2012-08-14 11:05:55 -0700 | [diff] [blame] | 314 | |
Kenneth Graunke | f3d0daf | 2012-08-26 00:28:38 -0700 | [diff] [blame] | 315 | int unit_id = prog->SamplerUnits[s]; |
| 316 | const struct gl_texture_unit *unit = &ctx->Texture.Unit[unit_id]; |
Kenneth Graunke | 1b05fc7 | 2011-12-06 15:36:21 -0800 | [diff] [blame] | 317 | |
Eric Anholt | ff9c3e8 | 2014-04-23 17:14:26 -0700 | [diff] [blame] | 318 | if (unit->_Current && unit->_Current->Target != GL_TEXTURE_BUFFER) { |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 319 | const struct gl_texture_object *t = unit->_Current; |
| 320 | const struct gl_texture_image *img = t->Image[0][t->BaseLevel]; |
| 321 | struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit_id); |
Kenneth Graunke | fe911c1 | 2012-06-16 13:50:03 -0700 | [diff] [blame] | 322 | |
Kenneth Graunke | 6d6aef7 | 2012-09-21 03:13:36 -0700 | [diff] [blame] | 323 | const bool alpha_depth = t->DepthMode == GL_ALPHA && |
| 324 | (img->_BaseFormat == GL_DEPTH_COMPONENT || |
| 325 | img->_BaseFormat == GL_DEPTH_STENCIL); |
| 326 | |
| 327 | /* Haswell handles texture swizzling as surface format overrides |
| 328 | * (except for GL_ALPHA); all other platforms need MOVs in the shader. |
| 329 | */ |
Kenneth Graunke | 5720832 | 2013-01-14 21:43:28 -0800 | [diff] [blame] | 330 | if (alpha_depth || (brw->gen < 8 && !brw->is_haswell)) |
Kenneth Graunke | 9db2098 | 2013-01-23 15:27:39 -0800 | [diff] [blame] | 331 | key->swizzles[s] = brw_get_texture_swizzle(ctx, t); |
Kenneth Graunke | fe911c1 | 2012-06-16 13:50:03 -0700 | [diff] [blame] | 332 | |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 333 | if (brw->gen < 8 && |
Kenneth Graunke | 2211696 | 2014-05-28 23:31:48 -0700 | [diff] [blame] | 334 | sampler->MinFilter != GL_NEAREST && |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 335 | sampler->MagFilter != GL_NEAREST) { |
| 336 | if (sampler->WrapS == GL_CLAMP) |
| 337 | key->gl_clamp_mask[0] |= 1 << s; |
| 338 | if (sampler->WrapT == GL_CLAMP) |
| 339 | key->gl_clamp_mask[1] |= 1 << s; |
| 340 | if (sampler->WrapR == GL_CLAMP) |
| 341 | key->gl_clamp_mask[2] |= 1 << s; |
| 342 | } |
Chris Forbes | cfa3c8a | 2013-08-11 09:55:30 +1200 | [diff] [blame] | 343 | |
Kenneth Graunke | 99c019e | 2017-01-05 02:51:38 -0800 | [diff] [blame] | 344 | /* gather4 for RG32* is broken in multiple ways on Gen7. */ |
Jason Ekstrand | b86dba8 | 2017-05-08 09:20:21 -0700 | [diff] [blame] | 345 | if (brw->gen == 7 && prog->nir->info.uses_texture_gather) { |
Kenneth Graunke | 99c019e | 2017-01-05 02:51:38 -0800 | [diff] [blame] | 346 | switch (img->InternalFormat) { |
| 347 | case GL_RG32I: |
| 348 | case GL_RG32UI: { |
| 349 | /* We have to override the format to R32G32_FLOAT_LD. |
| 350 | * This means that SCS_ALPHA and SCS_ONE will return 0x3f8 |
| 351 | * (1.0) rather than integer 1. This needs shader hacks. |
| 352 | * |
| 353 | * On Ivybridge, we whack W (alpha) to ONE in our key's |
| 354 | * swizzle. On Haswell, we look at the original texture |
| 355 | * swizzle, and use XYZW with channels overridden to ONE, |
| 356 | * leaving normal texture swizzling to SCS. |
| 357 | */ |
| 358 | unsigned src_swizzle = |
| 359 | brw->is_haswell ? t->_Swizzle : key->swizzles[s]; |
| 360 | for (int i = 0; i < 4; i++) { |
| 361 | unsigned src_comp = GET_SWZ(src_swizzle, i); |
| 362 | if (src_comp == SWIZZLE_ONE || src_comp == SWIZZLE_W) { |
| 363 | key->swizzles[i] &= ~(0x7 << (3 * i)); |
| 364 | key->swizzles[i] |= SWIZZLE_ONE << (3 * i); |
| 365 | } |
| 366 | } |
| 367 | /* fallthrough */ |
| 368 | } |
| 369 | case GL_RG32F: |
| 370 | /* The channel select for green doesn't work - we have to |
| 371 | * request blue. Haswell can use SCS for this, but Ivybridge |
| 372 | * needs a shader workaround. |
| 373 | */ |
| 374 | if (!brw->is_haswell) |
| 375 | key->gather_channel_quirk_mask |= 1 << s; |
| 376 | break; |
| 377 | } |
Chris Forbes | cfa3c8a | 2013-08-11 09:55:30 +1200 | [diff] [blame] | 378 | } |
Chris Forbes | 27359b8 | 2013-11-30 10:01:12 +1300 | [diff] [blame] | 379 | |
Chris Forbes | 2b7bbd8 | 2014-02-03 22:13:03 +1300 | [diff] [blame] | 380 | /* Gen6's gather4 is broken for UINT/SINT; we treat them as |
| 381 | * UNORM/FLOAT instead and fix it in the shader. |
| 382 | */ |
Jason Ekstrand | b86dba8 | 2017-05-08 09:20:21 -0700 | [diff] [blame] | 383 | if (brw->gen == 6 && prog->nir->info.uses_texture_gather) { |
Chris Forbes | 2b7bbd8 | 2014-02-03 22:13:03 +1300 | [diff] [blame] | 384 | key->gen6_gather_wa[s] = gen6_gather_workaround(img->InternalFormat); |
| 385 | } |
| 386 | |
Chris Forbes | 27359b8 | 2013-11-30 10:01:12 +1300 | [diff] [blame] | 387 | /* If this is a multisample sampler, and uses the CMS MSAA layout, |
| 388 | * then we need to emit slightly different code to first sample the |
| 389 | * MCS surface. |
| 390 | */ |
| 391 | struct intel_texture_object *intel_tex = |
| 392 | intel_texture_object((struct gl_texture_object *)t); |
| 393 | |
Topi Pohjolainen | cda8c2a | 2016-04-18 21:47:23 +0300 | [diff] [blame] | 394 | /* From gen9 onwards some single sampled buffers can also be |
| 395 | * compressed. These don't need ld2dms sampling along with mcs fetch. |
| 396 | */ |
Chris Forbes | 27359b8 | 2013-11-30 10:01:12 +1300 | [diff] [blame] | 397 | if (brw->gen >= 7 && |
Topi Pohjolainen | cda8c2a | 2016-04-18 21:47:23 +0300 | [diff] [blame] | 398 | intel_tex->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS && |
| 399 | intel_tex->mt->num_samples > 1) { |
Chris Forbes | 27359b8 | 2013-11-30 10:01:12 +1300 | [diff] [blame] | 400 | key->compressed_multisample_layout_mask |= 1 << s; |
Neil Roberts | 1a97cac | 2015-09-15 16:34:35 +0100 | [diff] [blame] | 401 | |
| 402 | if (intel_tex->mt->num_samples >= 16) { |
| 403 | assert(brw->gen >= 9); |
| 404 | key->msaa_16 |= 1 << s; |
| 405 | } |
Chris Forbes | 27359b8 | 2013-11-30 10:01:12 +1300 | [diff] [blame] | 406 | } |
Kristian Høgsberg Kristensen | 654e950 | 2016-05-01 21:22:54 -0700 | [diff] [blame] | 407 | |
| 408 | if (t->Target == GL_TEXTURE_EXTERNAL_OES && intel_tex->planar_format) { |
| 409 | switch (intel_tex->planar_format->components) { |
| 410 | case __DRI_IMAGE_COMPONENTS_Y_UV: |
| 411 | key->y_uv_image_mask |= 1 << s; |
| 412 | break; |
| 413 | case __DRI_IMAGE_COMPONENTS_Y_U_V: |
| 414 | key->y_u_v_image_mask |= 1 << s; |
| 415 | break; |
| 416 | case __DRI_IMAGE_COMPONENTS_Y_XUXV: |
| 417 | key->yx_xuxv_image_mask |= 1 << s; |
| 418 | break; |
Johnson Lin | 165e704 | 2017-06-16 13:51:34 +0800 | [diff] [blame^] | 419 | case __DRI_IMAGE_COMPONENTS_Y_UXVX: |
| 420 | key->xy_uxvx_image_mask |= 1 << s; |
| 421 | break; |
Kristian Høgsberg Kristensen | 654e950 | 2016-05-01 21:22:54 -0700 | [diff] [blame] | 422 | default: |
| 423 | break; |
| 424 | } |
| 425 | } |
| 426 | |
Kenneth Graunke | 1b05fc7 | 2011-12-06 15:36:21 -0800 | [diff] [blame] | 427 | } |
Kenneth Graunke | 1b05fc7 | 2011-12-06 15:36:21 -0800 | [diff] [blame] | 428 | } |
| 429 | } |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 430 | |
Carl Worth | a57672f | 2015-03-20 12:01:33 -0700 | [diff] [blame] | 431 | static bool |
Kenneth Graunke | b23b099 | 2016-04-27 11:26:08 -0700 | [diff] [blame] | 432 | brw_wm_state_dirty(const struct brw_context *brw) |
Carl Worth | a57672f | 2015-03-20 12:01:33 -0700 | [diff] [blame] | 433 | { |
| 434 | return brw_state_dirty(brw, |
| 435 | _NEW_BUFFERS | |
| 436 | _NEW_COLOR | |
| 437 | _NEW_DEPTH | |
| 438 | _NEW_FRAG_CLAMP | |
| 439 | _NEW_HINT | |
| 440 | _NEW_LIGHT | |
| 441 | _NEW_LINE | |
| 442 | _NEW_MULTISAMPLE | |
| 443 | _NEW_POLYGON | |
| 444 | _NEW_STENCIL | |
| 445 | _NEW_TEXTURE, |
| 446 | BRW_NEW_FRAGMENT_PROGRAM | |
| 447 | BRW_NEW_REDUCED_PRIMITIVE | |
| 448 | BRW_NEW_STATS_WM | |
| 449 | BRW_NEW_VUE_MAP_GEOM_OUT); |
| 450 | } |
| 451 | |
Carl Worth | 017081a | 2016-04-14 10:54:38 +1000 | [diff] [blame] | 452 | void |
Ian Romanick | 2b81cef | 2015-06-10 17:09:16 -0700 | [diff] [blame] | 453 | brw_wm_populate_key(struct brw_context *brw, struct brw_wm_prog_key *key) |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 454 | { |
Kenneth Graunke | 8c9a54e | 2013-07-06 00:46:38 -0700 | [diff] [blame] | 455 | struct gl_context *ctx = &brw->ctx; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 456 | /* BRW_NEW_FRAGMENT_PROGRAM */ |
Timothy Arceri | 13d0cf5 | 2016-10-18 16:17:14 +1100 | [diff] [blame] | 457 | const struct brw_program *fp = brw_program_const(brw->fragment_program); |
Kenneth Graunke | 387a3d4 | 2011-12-08 12:15:59 -0800 | [diff] [blame] | 458 | const struct gl_program *prog = (struct gl_program *) brw->fragment_program; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 459 | GLuint lookup = 0; |
| 460 | GLuint line_aa; |
Paul Berry | 82d2596 | 2012-06-20 13:40:45 -0700 | [diff] [blame] | 461 | |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 462 | memset(key, 0, sizeof(*key)); |
| 463 | |
| 464 | /* Build the index for table lookup |
| 465 | */ |
Kenneth Graunke | 53631be | 2013-07-06 00:36:46 -0700 | [diff] [blame] | 466 | if (brw->gen < 6) { |
Kenneth Graunke | 86e401b | 2012-07-12 11:25:58 -0700 | [diff] [blame] | 467 | /* _NEW_COLOR */ |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 468 | if (prog->info.fs.uses_discard || ctx->Color.AlphaEnabled) { |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 469 | lookup |= BRW_WM_IZ_PS_KILL_ALPHATEST_BIT; |
Timothy Arceri | 556335e | 2016-10-05 15:13:23 +1100 | [diff] [blame] | 470 | } |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 471 | |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 472 | if (prog->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) { |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 473 | lookup |= BRW_WM_IZ_PS_COMPUTES_DEPTH_BIT; |
Timothy Arceri | 7ef8286 | 2016-10-05 16:24:56 +1100 | [diff] [blame] | 474 | } |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 475 | |
Kenneth Graunke | 2f8351a | 2012-06-16 16:34:50 -0700 | [diff] [blame] | 476 | /* _NEW_DEPTH */ |
| 477 | if (ctx->Depth.Test) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 478 | lookup |= BRW_WM_IZ_DEPTH_TEST_ENABLE_BIT; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 479 | |
Kenneth Graunke | ff0253a | 2016-11-16 18:29:22 -0800 | [diff] [blame] | 480 | if (brw_depth_writes_enabled(brw)) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 481 | lookup |= BRW_WM_IZ_DEPTH_WRITE_ENABLE_BIT; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 482 | |
Eric Anholt | 94ecf91 | 2013-06-20 09:08:30 -0700 | [diff] [blame] | 483 | /* _NEW_STENCIL | _NEW_BUFFERS */ |
Marek Olšák | c240883 | 2017-06-09 20:37:34 +0200 | [diff] [blame] | 484 | if (brw->stencil_enabled) { |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 485 | lookup |= BRW_WM_IZ_STENCIL_TEST_ENABLE_BIT; |
Kenneth Graunke | 2f8351a | 2012-06-16 16:34:50 -0700 | [diff] [blame] | 486 | |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 487 | if (ctx->Stencil.WriteMask[0] || |
| 488 | ctx->Stencil.WriteMask[ctx->Stencil._BackFace]) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 489 | lookup |= BRW_WM_IZ_STENCIL_WRITE_ENABLE_BIT; |
Kenneth Graunke | 2f8351a | 2012-06-16 16:34:50 -0700 | [diff] [blame] | 490 | } |
| 491 | key->iz_lookup = lookup; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 492 | } |
| 493 | |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 494 | line_aa = BRW_WM_AA_NEVER; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 495 | |
| 496 | /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */ |
Eric Anholt | 052c1d6 | 2009-01-30 14:32:23 -0800 | [diff] [blame] | 497 | if (ctx->Line.SmoothFlag) { |
Kenneth Graunke | fe0a8cb | 2013-07-03 11:55:59 -0700 | [diff] [blame] | 498 | if (brw->reduced_primitive == GL_LINES) { |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 499 | line_aa = BRW_WM_AA_ALWAYS; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 500 | } |
Kenneth Graunke | fe0a8cb | 2013-07-03 11:55:59 -0700 | [diff] [blame] | 501 | else if (brw->reduced_primitive == GL_TRIANGLES) { |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 502 | if (ctx->Polygon.FrontMode == GL_LINE) { |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 503 | line_aa = BRW_WM_AA_SOMETIMES; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 504 | |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 505 | if (ctx->Polygon.BackMode == GL_LINE || |
| 506 | (ctx->Polygon.CullFlag && |
| 507 | ctx->Polygon.CullFaceMode == GL_BACK)) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 508 | line_aa = BRW_WM_AA_ALWAYS; |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 509 | } |
| 510 | else if (ctx->Polygon.BackMode == GL_LINE) { |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 511 | line_aa = BRW_WM_AA_SOMETIMES; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 512 | |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 513 | if ((ctx->Polygon.CullFlag && |
| 514 | ctx->Polygon.CullFaceMode == GL_FRONT)) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 515 | line_aa = BRW_WM_AA_ALWAYS; |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 516 | } |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 517 | } |
| 518 | } |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 519 | |
Eric Anholt | 16f8c82 | 2010-11-11 09:30:16 -0800 | [diff] [blame] | 520 | key->line_aa = line_aa; |
Kenneth Graunke | 6cc14c2 | 2012-08-26 00:47:44 -0700 | [diff] [blame] | 521 | |
Chia-I Wu | 848c0e7 | 2013-09-12 13:00:52 +0800 | [diff] [blame] | 522 | /* _NEW_HINT */ |
Kenneth Graunke | 2a4f572 | 2014-11-30 21:58:03 -0800 | [diff] [blame] | 523 | key->high_quality_derivatives = |
| 524 | ctx->Hint.FragmentShaderDerivative == GL_NICEST; |
Chia-I Wu | 848c0e7 | 2013-09-12 13:00:52 +0800 | [diff] [blame] | 525 | |
Kenneth Graunke | 53631be | 2013-07-06 00:36:46 -0700 | [diff] [blame] | 526 | if (brw->gen < 6) |
Kenneth Graunke | ec995de | 2013-07-03 14:26:01 -0700 | [diff] [blame] | 527 | key->stats_wm = brw->stats_wm; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 528 | |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 529 | /* _NEW_LIGHT */ |
Eric Anholt | 052c1d6 | 2009-01-30 14:32:23 -0800 | [diff] [blame] | 530 | key->flat_shade = (ctx->Light.ShadeModel == GL_FLAT); |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 531 | |
Eric Anholt | d22e2eb | 2011-04-15 14:40:09 -0700 | [diff] [blame] | 532 | /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */ |
| 533 | key->clamp_fragment_color = ctx->Color._ClampFragmentColor; |
| 534 | |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 535 | /* _NEW_TEXTURE */ |
Timothy Arceri | 8f1ca0e | 2016-07-05 17:02:46 +1000 | [diff] [blame] | 536 | brw_populate_sampler_prog_key_data(ctx, prog, &key->tex); |
Eric Anholt | 9c8f27b | 2008-02-28 13:18:12 -0800 | [diff] [blame] | 537 | |
| 538 | /* _NEW_BUFFERS */ |
Eric Anholt | 1b80622 | 2011-01-30 21:13:17 -0800 | [diff] [blame] | 539 | key->nr_color_regions = ctx->DrawBuffer->_NumColorDrawBuffers; |
Chris Forbes | 1415a18 | 2013-07-01 23:30:55 +1200 | [diff] [blame] | 540 | |
Kenneth Graunke | b3340cd | 2016-01-20 17:33:14 -0800 | [diff] [blame] | 541 | /* _NEW_COLOR */ |
| 542 | key->force_dual_color_blend = brw->dual_color_blend_by_location && |
| 543 | (ctx->Color.BlendEnabled & 1) && ctx->Color.Blend[0]._UsesDualSrc; |
| 544 | |
Chris Forbes | 1415a18 | 2013-07-01 23:30:55 +1200 | [diff] [blame] | 545 | /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */ |
| 546 | key->replicate_alpha = ctx->DrawBuffer->_NumColorDrawBuffers > 1 && |
Anuj Phogat | 329ae92 | 2016-10-20 11:40:40 -0700 | [diff] [blame] | 547 | (_mesa_is_alpha_test_enabled(ctx) || |
| 548 | _mesa_is_alpha_to_coverage_enabled(ctx)); |
Brian Paul | 9ef33b8 | 2009-10-29 14:53:53 -0600 | [diff] [blame] | 549 | |
Anuj Phogat | 65d0452 | 2013-10-24 15:53:05 -0700 | [diff] [blame] | 550 | /* _NEW_BUFFERS _NEW_MULTISAMPLE */ |
Anuj Phogat | a92e5f7 | 2014-01-06 13:59:18 -0800 | [diff] [blame] | 551 | /* Ignore sample qualifier while computing this flag. */ |
Jason Ekstrand | 712a980 | 2016-05-09 17:48:24 -0700 | [diff] [blame] | 552 | if (ctx->Multisample.Enabled) { |
| 553 | key->persample_interp = |
| 554 | ctx->Multisample.SampleShading && |
| 555 | (ctx->Multisample.MinSampleShadingValue * |
| 556 | _mesa_geometric_samples(ctx->DrawBuffer) > 1); |
Anuj Phogat | a92e5f7 | 2014-01-06 13:59:18 -0800 | [diff] [blame] | 557 | |
Jason Ekstrand | 712a980 | 2016-05-09 17:48:24 -0700 | [diff] [blame] | 558 | key->multisample_fbo = _mesa_geometric_samples(ctx->DrawBuffer) > 1; |
| 559 | } |
Anuj Phogat | e12bbb5 | 2013-10-24 16:17:08 -0700 | [diff] [blame] | 560 | |
Paul Berry | bf9bfe8 | 2013-03-17 11:29:28 -0700 | [diff] [blame] | 561 | /* BRW_NEW_VUE_MAP_GEOM_OUT */ |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 562 | if (brw->gen < 6 || _mesa_bitcount_64(prog->info.inputs_read & |
| 563 | BRW_FS_VARYING_INPUT_MASK) > 16) { |
Paul Berry | 0a0deb9 | 2013-03-20 10:15:52 -0700 | [diff] [blame] | 564 | key->input_slots_valid = brw->vue_map_geom_out.slots_valid; |
Timothy Arceri | 7627fbd | 2016-10-05 16:45:27 +1100 | [diff] [blame] | 565 | } |
Eric Anholt | 0f5113d | 2009-05-14 09:49:45 -0700 | [diff] [blame] | 566 | |
Chris Forbes | 1080fc6 | 2013-10-27 12:09:51 +1300 | [diff] [blame] | 567 | /* _NEW_COLOR | _NEW_BUFFERS */ |
| 568 | /* Pre-gen6, the hardware alpha test always used each render |
| 569 | * target's alpha to do alpha test, as opposed to render target 0's alpha |
| 570 | * like GL requires. Fix that by building the alpha test into the |
| 571 | * shader, and we'll skip enabling the fixed function alpha test. |
| 572 | */ |
Ian Romanick | 2b81cef | 2015-06-10 17:09:16 -0700 | [diff] [blame] | 573 | if (brw->gen < 6 && ctx->DrawBuffer->_NumColorDrawBuffers > 1 && |
| 574 | ctx->Color.AlphaEnabled) { |
Chris Forbes | 1080fc6 | 2013-10-27 12:09:51 +1300 | [diff] [blame] | 575 | key->alpha_test_func = ctx->Color.AlphaFunc; |
| 576 | key->alpha_test_ref = ctx->Color.AlphaRef; |
| 577 | } |
| 578 | |
Brian Paul | 55d33e1 | 2009-02-20 10:49:30 -0700 | [diff] [blame] | 579 | /* The unique fragment program ID */ |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 580 | key->program_string_id = fp->id; |
Francisco Jerez | 40b23ad | 2016-07-21 20:32:12 -0700 | [diff] [blame] | 581 | |
| 582 | /* Whether reads from the framebuffer should behave coherently. */ |
| 583 | key->coherent_fb_fetch = ctx->Extensions.MESA_shader_framebuffer_fetch; |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 584 | } |
| 585 | |
Carl Worth | 4a6c6c4 | 2015-02-11 13:53:31 -0800 | [diff] [blame] | 586 | void |
Eric Anholt | dc9a753 | 2011-10-22 11:33:54 -0700 | [diff] [blame] | 587 | brw_upload_wm_prog(struct brw_context *brw) |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 588 | { |
| 589 | struct brw_wm_prog_key key; |
Timothy Arceri | 13d0cf5 | 2016-10-18 16:17:14 +1100 | [diff] [blame] | 590 | struct brw_program *fp = (struct brw_program *) brw->fragment_program; |
Eric Anholt | 662f1b4 | 2011-03-11 19:19:01 -0800 | [diff] [blame] | 591 | |
Carl Worth | a57672f | 2015-03-20 12:01:33 -0700 | [diff] [blame] | 592 | if (!brw_wm_state_dirty(brw)) |
Carl Worth | 4a6c6c4 | 2015-02-11 13:53:31 -0800 | [diff] [blame] | 593 | return; |
| 594 | |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 595 | brw_wm_populate_key(brw, &key); |
| 596 | |
Kenneth Graunke | 67c4980 | 2014-09-26 11:38:06 -0700 | [diff] [blame] | 597 | if (!brw_search_cache(&brw->cache, BRW_CACHE_FS_PROG, |
Timothy Arceri | a38c809 | 2016-10-05 15:42:02 +1100 | [diff] [blame] | 598 | &key, sizeof(key), |
| 599 | &brw->wm.base.prog_offset, |
Kenneth Graunke | 16d5536 | 2016-09-08 23:48:53 -0700 | [diff] [blame] | 600 | &brw->wm.base.prog_data)) { |
Timothy Arceri | 6e3f609 | 2016-11-04 16:04:01 +1100 | [diff] [blame] | 601 | bool success = brw_codegen_wm_prog(brw, fp, &key, |
Timothy Arceri | 91d61fb | 2016-10-20 09:59:00 +1100 | [diff] [blame] | 602 | &brw->vue_map_geom_out); |
Brian Paul | 4170227 | 2011-10-07 10:38:30 -0600 | [diff] [blame] | 603 | (void) success; |
Eric Anholt | 8752764 | 2011-05-16 15:10:26 -0700 | [diff] [blame] | 604 | assert(success); |
| 605 | } |
Eric Anholt | 9f344b3 | 2006-08-09 19:14:05 +0000 | [diff] [blame] | 606 | } |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 607 | |
| 608 | bool |
Timothy Arceri | 6e3f609 | 2016-11-04 16:04:01 +1100 | [diff] [blame] | 609 | brw_fs_precompile(struct gl_context *ctx, struct gl_program *prog) |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 610 | { |
| 611 | struct brw_context *brw = brw_context(ctx); |
| 612 | struct brw_wm_prog_key key; |
| 613 | |
Timothy Arceri | 13d0cf5 | 2016-10-18 16:17:14 +1100 | [diff] [blame] | 614 | struct brw_program *bfp = brw_program(prog); |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 615 | |
| 616 | memset(&key, 0, sizeof(key)); |
| 617 | |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 618 | uint64_t outputs_written = prog->info.outputs_written; |
Timothy Arceri | 7ef8286 | 2016-10-05 16:24:56 +1100 | [diff] [blame] | 619 | |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 620 | if (brw->gen < 6) { |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 621 | if (prog->info.fs.uses_discard) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 622 | key.iz_lookup |= BRW_WM_IZ_PS_KILL_ALPHATEST_BIT; |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 623 | |
Timothy Arceri | 7ef8286 | 2016-10-05 16:24:56 +1100 | [diff] [blame] | 624 | if (outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 625 | key.iz_lookup |= BRW_WM_IZ_PS_COMPUTES_DEPTH_BIT; |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 626 | |
| 627 | /* Just assume depth testing. */ |
Jason Ekstrand | 8123402 | 2017-02-28 16:33:49 -0800 | [diff] [blame] | 628 | key.iz_lookup |= BRW_WM_IZ_DEPTH_TEST_ENABLE_BIT; |
| 629 | key.iz_lookup |= BRW_WM_IZ_DEPTH_WRITE_ENABLE_BIT; |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 630 | } |
| 631 | |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 632 | if (brw->gen < 6 || _mesa_bitcount_64(prog->info.inputs_read & |
Timothy Arceri | 7627fbd | 2016-10-05 16:45:27 +1100 | [diff] [blame] | 633 | BRW_FS_VARYING_INPUT_MASK) > 16) { |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 634 | key.input_slots_valid = prog->info.inputs_read | VARYING_BIT_POS; |
Timothy Arceri | 7627fbd | 2016-10-05 16:45:27 +1100 | [diff] [blame] | 635 | } |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 636 | |
Timothy Arceri | 3423488 | 2016-10-19 13:23:37 +1100 | [diff] [blame] | 637 | brw_setup_tex_for_precompile(brw, &key.tex, prog); |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 638 | |
Timothy Arceri | 7ef8286 | 2016-10-05 16:24:56 +1100 | [diff] [blame] | 639 | key.nr_color_regions = _mesa_bitcount_64(outputs_written & |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 640 | ~(BITFIELD64_BIT(FRAG_RESULT_DEPTH) | |
Francisco Jerez | c8f5bd2 | 2016-08-22 18:50:41 -0700 | [diff] [blame] | 641 | BITFIELD64_BIT(FRAG_RESULT_STENCIL) | |
| 642 | BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK))); |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 643 | |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 644 | key.program_string_id = bfp->id; |
| 645 | |
Francisco Jerez | 40b23ad | 2016-07-21 20:32:12 -0700 | [diff] [blame] | 646 | /* Whether reads from the framebuffer should behave coherently. */ |
| 647 | key.coherent_fb_fetch = ctx->Extensions.MESA_shader_framebuffer_fetch; |
| 648 | |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 649 | uint32_t old_prog_offset = brw->wm.base.prog_offset; |
Kenneth Graunke | 16d5536 | 2016-09-08 23:48:53 -0700 | [diff] [blame] | 650 | struct brw_stage_prog_data *old_prog_data = brw->wm.base.prog_data; |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 651 | |
Timothy Arceri | 91d61fb | 2016-10-20 09:59:00 +1100 | [diff] [blame] | 652 | struct brw_vue_map vue_map; |
| 653 | if (brw->gen < 6) { |
| 654 | brw_compute_vue_map(&brw->screen->devinfo, &vue_map, |
Timothy Arceri | 17e28a1 | 2016-10-19 13:45:18 +1100 | [diff] [blame] | 655 | prog->info.inputs_read | VARYING_BIT_POS, |
Timothy Arceri | 91d61fb | 2016-10-20 09:59:00 +1100 | [diff] [blame] | 656 | false); |
| 657 | } |
| 658 | |
Timothy Arceri | 6e3f609 | 2016-11-04 16:04:01 +1100 | [diff] [blame] | 659 | bool success = brw_codegen_wm_prog(brw, bfp, &key, &vue_map); |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 660 | |
| 661 | brw->wm.base.prog_offset = old_prog_offset; |
Kenneth Graunke | 16d5536 | 2016-09-08 23:48:53 -0700 | [diff] [blame] | 662 | brw->wm.base.prog_data = old_prog_data; |
Kristian Høgsberg Kristensen | 84f2ed2 | 2015-09-04 16:55:03 -0700 | [diff] [blame] | 663 | |
| 664 | return success; |
| 665 | } |