1 /* 2 * Copyright 2015 Red Hat 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 * 23 * Authors: 24 * Rob Clark <robclark (at) freedesktop.org> 25 */ 26 27 #include "nir.h" 28 #include "nir_builder.h" 29 30 #define MAX_CLIP_PLANES 8 31 32 /* Generates the lowering code for user-clip-planes, generating CLIPDIST 33 * from UCP[n] + CLIPVERTEX or POSITION. Additionally, an optional pass 34 * for fragment shaders to insert conditional kill's based on the inter- 35 * polated CLIPDIST 36 * 37 * NOTE: should be run after nir_lower_outputs_to_temporaries() (or at 38 * least in scenarios where you can count on each output written once 39 * and only once). 40 */ 41 42 43 static nir_variable * 44 create_clipdist_var(nir_shader *shader, unsigned drvloc, 45 bool output, gl_varying_slot slot) 46 { 47 nir_variable *var = rzalloc(shader, nir_variable); 48 49 var->data.driver_location = drvloc; 50 var->type = glsl_vec4_type(); 51 var->data.mode = output ? nir_var_shader_out : nir_var_shader_in; 52 var->name = ralloc_asprintf(var, "clipdist_%d", drvloc); 53 var->data.index = 0; 54 var->data.location = slot; 55 56 if (output) { 57 exec_list_push_tail(&shader->outputs, &var->node); 58 shader->num_outputs++; /* TODO use type_size() */ 59 } 60 else { 61 exec_list_push_tail(&shader->inputs, &var->node); 62 shader->num_inputs++; /* TODO use type_size() */ 63 } 64 return var; 65 } 66 67 static void 68 store_clipdist_output(nir_builder *b, nir_variable *out, nir_ssa_def **val) 69 { 70 nir_intrinsic_instr *store; 71 72 store = nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_output); 73 store->num_components = 4; 74 nir_intrinsic_set_base(store, out->data.driver_location); 75 nir_intrinsic_set_write_mask(store, 0xf); 76 store->src[0].ssa = nir_vec4(b, val[0], val[1], val[2], val[3]); 77 store->src[0].is_ssa = true; 78 store->src[1] = nir_src_for_ssa(nir_imm_int(b, 0)); 79 nir_builder_instr_insert(b, &store->instr); 80 } 81 82 static void 83 load_clipdist_input(nir_builder *b, nir_variable *in, nir_ssa_def **val) 84 { 85 nir_intrinsic_instr *load; 86 87 load = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_input); 88 load->num_components = 4; 89 nir_intrinsic_set_base(load, in->data.driver_location); 90 load->src[0] = nir_src_for_ssa(nir_imm_int(b, 0)); 91 nir_ssa_dest_init(&load->instr, &load->dest, 4, 32, NULL); 92 nir_builder_instr_insert(b, &load->instr); 93 94 val[0] = nir_channel(b, &load->dest.ssa, 0); 95 val[1] = nir_channel(b, &load->dest.ssa, 1); 96 val[2] = nir_channel(b, &load->dest.ssa, 2); 97 val[3] = nir_channel(b, &load->dest.ssa, 3); 98 } 99 100 static nir_ssa_def * 101 find_output_in_block(nir_block *block, unsigned drvloc) 102 { 103 nir_foreach_instr(instr, block) { 104 105 if (instr->type == nir_instr_type_intrinsic) { 106 nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr); 107 if ((intr->intrinsic == nir_intrinsic_store_output) && 108 nir_intrinsic_base(intr) == drvloc) { 109 assert(intr->src[0].is_ssa); 110 assert(nir_src_as_const_value(intr->src[1])); 111 return intr->src[0].ssa; 112 } 113 } 114 } 115 116 return NULL; 117 } 118 119 /* TODO: maybe this would be a useful helper? 120 * NOTE: assumes each output is written exactly once (and unconditionally) 121 * so if needed nir_lower_outputs_to_temporaries() 122 */ 123 static nir_ssa_def * 124 find_output(nir_shader *shader, unsigned drvloc) 125 { 126 nir_ssa_def *def = NULL; 127 nir_foreach_function(function, shader) { 128 if (function->impl) { 129 nir_foreach_block_reverse(block, function->impl) { 130 nir_ssa_def *new_def = find_output_in_block(block, drvloc); 131 assert(!(new_def && def)); 132 def = new_def; 133 #if !defined(DEBUG) 134 /* for debug builds, scan entire shader to assert 135 * if output is written multiple times. For release 136 * builds just assume all is well and bail when we 137 * find first: 138 */ 139 if (def) 140 break; 141 #endif 142 } 143 } 144 } 145 146 return def; 147 } 148 149 /* 150 * VS lowering 151 */ 152 153 static void 154 lower_clip_vs(nir_function_impl *impl, unsigned ucp_enables, 155 nir_ssa_def *cv, nir_variable **out) 156 { 157 nir_ssa_def *clipdist[MAX_CLIP_PLANES]; 158 nir_builder b; 159 160 nir_builder_init(&b, impl); 161 162 /* NIR should ensure that, even in case of loops/if-else, there 163 * should be only a single predecessor block to end_block, which 164 * makes the perfect place to insert the clipdist calculations. 165 * 166 * NOTE: in case of early return's, these would have to be lowered 167 * to jumps to end_block predecessor in a previous pass. Not sure 168 * if there is a good way to sanity check this, but for now the 169 * users of this pass don't support sub-routines. 170 */ 171 assert(impl->end_block->predecessors->entries == 1); 172 b.cursor = nir_after_cf_list(&impl->body); 173 174 for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) { 175 if (ucp_enables & (1 << plane)) { 176 nir_ssa_def *ucp = 177 nir_load_system_value(&b, nir_intrinsic_load_user_clip_plane, plane); 178 179 /* calculate clipdist[plane] - dot(ucp, cv): */ 180 clipdist[plane] = nir_fdot4(&b, ucp, cv); 181 } 182 else { 183 /* 0.0 == don't-clip == disabled: */ 184 clipdist[plane] = nir_imm_float(&b, 0.0); 185 } 186 } 187 188 if (ucp_enables & 0x0f) 189 store_clipdist_output(&b, out[0], &clipdist[0]); 190 if (ucp_enables & 0xf0) 191 store_clipdist_output(&b, out[1], &clipdist[4]); 192 193 nir_metadata_preserve(impl, nir_metadata_dominance); 194 } 195 196 /* ucp_enables is bitmask of enabled ucp's. Actual ucp values are 197 * passed in to shader via user_clip_plane system-values 198 */ 199 void 200 nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables) 201 { 202 int clipvertex = -1; 203 int position = -1; 204 int maxloc = -1; 205 nir_ssa_def *cv; 206 nir_variable *out[2] = { NULL }; 207 208 if (!ucp_enables) 209 return; 210 211 /* find clipvertex/position outputs: */ 212 nir_foreach_variable(var, &shader->outputs) { 213 int loc = var->data.driver_location; 214 215 /* keep track of last used driver-location.. we'll be 216 * appending CLIP_DIST0/CLIP_DIST1 after last existing 217 * output: 218 */ 219 maxloc = MAX2(maxloc, loc); 220 221 switch (var->data.location) { 222 case VARYING_SLOT_POS: 223 position = loc; 224 break; 225 case VARYING_SLOT_CLIP_VERTEX: 226 clipvertex = loc; 227 break; 228 case VARYING_SLOT_CLIP_DIST0: 229 case VARYING_SLOT_CLIP_DIST1: 230 /* if shader is already writing CLIPDIST, then 231 * there should be no user-clip-planes to deal 232 * with. 233 */ 234 return; 235 } 236 } 237 238 if (clipvertex != -1) 239 cv = find_output(shader, clipvertex); 240 else if (position != -1) 241 cv = find_output(shader, position); 242 else 243 return; 244 245 /* insert CLIPDIST outputs: */ 246 if (ucp_enables & 0x0f) 247 out[0] = 248 create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST0); 249 if (ucp_enables & 0xf0) 250 out[1] = 251 create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST1); 252 253 nir_foreach_function(function, shader) { 254 if (!strcmp(function->name, "main")) 255 lower_clip_vs(function->impl, ucp_enables, cv, out); 256 } 257 } 258 259 /* 260 * FS lowering 261 */ 262 263 static void 264 lower_clip_fs(nir_function_impl *impl, unsigned ucp_enables, 265 nir_variable **in) 266 { 267 nir_ssa_def *clipdist[MAX_CLIP_PLANES]; 268 nir_builder b; 269 270 nir_builder_init(&b, impl); 271 b.cursor = nir_before_cf_list(&impl->body); 272 273 if (ucp_enables & 0x0f) 274 load_clipdist_input(&b, in[0], &clipdist[0]); 275 if (ucp_enables & 0xf0) 276 load_clipdist_input(&b, in[1], &clipdist[4]); 277 278 for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) { 279 if (ucp_enables & (1 << plane)) { 280 nir_intrinsic_instr *discard; 281 nir_ssa_def *cond; 282 283 cond = nir_flt(&b, clipdist[plane], nir_imm_float(&b, 0.0)); 284 285 discard = nir_intrinsic_instr_create(b.shader, 286 nir_intrinsic_discard_if); 287 discard->src[0] = nir_src_for_ssa(cond); 288 nir_builder_instr_insert(&b, &discard->instr); 289 290 b.shader->info->fs.uses_discard = true; 291 } 292 } 293 } 294 295 /* insert conditional kill based on interpolated CLIPDIST 296 */ 297 void 298 nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables) 299 { 300 nir_variable *in[2]; 301 int maxloc = -1; 302 303 if (!ucp_enables) 304 return; 305 306 nir_foreach_variable(var, &shader->inputs) { 307 int loc = var->data.driver_location; 308 309 /* keep track of last used driver-location.. we'll be 310 * appending CLIP_DIST0/CLIP_DIST1 after last existing 311 * input: 312 */ 313 maxloc = MAX2(maxloc, loc); 314 } 315 316 /* The shader won't normally have CLIPDIST inputs, so we 317 * must add our own: 318 */ 319 /* insert CLIPDIST outputs: */ 320 if (ucp_enables & 0x0f) 321 in[0] = 322 create_clipdist_var(shader, ++maxloc, false, 323 VARYING_SLOT_CLIP_DIST0); 324 if (ucp_enables & 0xf0) 325 in[1] = 326 create_clipdist_var(shader, ++maxloc, false, 327 VARYING_SLOT_CLIP_DIST1); 328 329 nir_foreach_function(function, shader) { 330 if (!strcmp(function->name, "main")) 331 lower_clip_fs(function->impl, ucp_enables, in); 332 } 333 } 334
