/* * Copyright © 2015 Red Hat * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. * * Authors: * Rob Clark <robclark@freedesktop.org> */ #include "nir.h" #include "nir_builder.h" #define MAX_CLIP_PLANES 8 /* Generates the lowering code for user-clip-planes, generating CLIPDIST * from UCP[n] + CLIPVERTEX or POSITION. Additionally, an optional pass * for fragment shaders to insert conditional kills based on the inter- * polated CLIPDIST * * NOTE: should be run after nir_lower_outputs_to_temporaries() (or at * least in scenarios where you can count on each output written once * and only once). */ static nir_variable * create_clipdist_var(nir_shader *shader, unsigned drvloc, bool output, gl_varying_slot slot) { nir_variable *var = rzalloc(shader, nir_variable); var->data.driver_location = drvloc; var->type = glsl_vec4_type(); var->data.mode = output ? nir_var_shader_out : nir_var_shader_in; var->name = ralloc_asprintf(var, "clipdist_%d", drvloc); var->data.index = 0; var->data.location = slot; if (output) { exec_list_push_tail(&shader->outputs, &var->node); shader->num_outputs++; /* TODO use type_size() */ } else { exec_list_push_tail(&shader->inputs, &var->node); shader->num_inputs++; /* TODO use type_size() */ } return var; } static void store_clipdist_output(nir_builder *b, nir_variable *out, nir_ssa_def **val) { nir_intrinsic_instr *store; store = nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_output); store->num_components = 4; nir_intrinsic_set_base(store, out->data.driver_location); nir_intrinsic_set_write_mask(store, 0xf); store->src[0].ssa = nir_vec4(b, val[0], val[1], val[2], val[3]); store->src[0].is_ssa = true; store->src[1] = nir_src_for_ssa(nir_imm_int(b, 0)); nir_builder_instr_insert(b, &store->instr); } static void load_clipdist_input(nir_builder *b, nir_variable *in, nir_ssa_def **val) { nir_intrinsic_instr *load; load = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_input); load->num_components = 4; nir_intrinsic_set_base(load, in->data.driver_location); load->src[0] = nir_src_for_ssa(nir_imm_int(b, 0)); nir_ssa_dest_init(&load->instr, &load->dest, 4, 32, NULL); nir_builder_instr_insert(b, &load->instr); val[0] = nir_channel(b, &load->dest.ssa, 0); val[1] = nir_channel(b, &load->dest.ssa, 1); val[2] = nir_channel(b, &load->dest.ssa, 2); val[3] = nir_channel(b, &load->dest.ssa, 3); } static nir_ssa_def * find_output_in_block(nir_block *block, unsigned drvloc) { nir_foreach_instr(instr, block) { if (instr->type == nir_instr_type_intrinsic) { nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr); if ((intr->intrinsic == nir_intrinsic_store_output) && nir_intrinsic_base(intr) == drvloc) { assert(intr->src[0].is_ssa); assert(nir_src_is_const(intr->src[1])); return intr->src[0].ssa; } } } return NULL; } /* TODO: maybe this would be a useful helper? * NOTE: assumes each output is written exactly once (and unconditionally) * so if needed nir_lower_outputs_to_temporaries() */ static nir_ssa_def * find_output(nir_shader *shader, unsigned drvloc) { nir_ssa_def *def = NULL; nir_foreach_function(function, shader) { if (function->impl) { nir_foreach_block_reverse(block, function->impl) { nir_ssa_def *new_def = find_output_in_block(block, drvloc); assert(!(new_def && def)); def = new_def; #if !defined(DEBUG) /* for debug builds, scan entire shader to assert * if output is written multiple times. For release * builds just assume all is well and bail when we * find first: */ if (def) break; #endif } } } return def; } /* * VS lowering */ /* ucp_enables is bitmask of enabled ucps. Actual ucp values are * passed in to shader via user_clip_plane system-values * * If use_vars is true, the pass will use variable loads and stores instead * of working with store_output intrinsics. */ bool nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables, bool use_vars) { nir_function_impl *impl = nir_shader_get_entrypoint(shader); nir_ssa_def *clipdist[MAX_CLIP_PLANES]; nir_builder b; int maxloc = -1; nir_variable *position = NULL; nir_variable *clipvertex = NULL; nir_ssa_def *cv; nir_variable *out[2] = { NULL }; if (!ucp_enables) return false; nir_builder_init(&b, impl); /* NIR should ensure that, even in case of loops/if-else, there * should be only a single predecessor block to end_block, which * makes the perfect place to insert the clipdist calculations. * * NOTE: in case of early returns, these would have to be lowered * to jumps to end_block predecessor in a previous pass. Not sure * if there is a good way to sanity check this, but for now the * users of this pass don't support sub-routines. */ assert(impl->end_block->predecessors->entries == 1); b.cursor = nir_after_cf_list(&impl->body); /* find clipvertex/position outputs: */ nir_foreach_variable(var, &shader->outputs) { switch (var->data.location) { case VARYING_SLOT_POS: position = var; break; case VARYING_SLOT_CLIP_VERTEX: clipvertex = var; break; case VARYING_SLOT_CLIP_DIST0: case VARYING_SLOT_CLIP_DIST1: /* if shader is already writing CLIPDIST, then * there should be no user-clip-planes to deal * with. * * We assume nir_remove_dead_variables has removed the clipdist * variables if they're not written. */ return false; } } if (use_vars) { cv = nir_load_var(&b, clipvertex ? clipvertex : position); if (clipvertex) { exec_node_remove(&clipvertex->node); clipvertex->data.mode = nir_var_shader_temp; exec_list_push_tail(&shader->globals, &clipvertex->node); } } else { if (clipvertex) cv = find_output(shader, clipvertex->data.driver_location); else if (position) cv = find_output(shader, position->data.driver_location); else return false; } /* insert CLIPDIST outputs: */ if (ucp_enables & 0x0f) out[0] = create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST0); if (ucp_enables & 0xf0) out[1] = create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST1); for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) { if (ucp_enables & (1 << plane)) { nir_ssa_def *ucp = nir_load_user_clip_plane(&b, plane); /* calculate clipdist[plane] - dot(ucp, cv): */ clipdist[plane] = nir_fdot4(&b, ucp, cv); } else { /* 0.0 == don't-clip == disabled: */ clipdist[plane] = nir_imm_float(&b, 0.0); } } if (use_vars) { if (ucp_enables & 0x0f) nir_store_var(&b, out[0], nir_vec(&b, clipdist, 4), 0xf); if (ucp_enables & 0xf0) nir_store_var(&b, out[1], nir_vec(&b, &clipdist[4], 4), 0xf); } else { if (ucp_enables & 0x0f) store_clipdist_output(&b, out[0], &clipdist[0]); if (ucp_enables & 0xf0) store_clipdist_output(&b, out[1], &clipdist[4]); } nir_metadata_preserve(impl, nir_metadata_dominance); return true; } /* * FS lowering */ static void lower_clip_fs(nir_function_impl *impl, unsigned ucp_enables, nir_variable **in) { nir_ssa_def *clipdist[MAX_CLIP_PLANES]; nir_builder b; nir_builder_init(&b, impl); b.cursor = nir_before_cf_list(&impl->body); if (ucp_enables & 0x0f) load_clipdist_input(&b, in[0], &clipdist[0]); if (ucp_enables & 0xf0) load_clipdist_input(&b, in[1], &clipdist[4]); for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) { if (ucp_enables & (1 << plane)) { nir_intrinsic_instr *discard; nir_ssa_def *cond; cond = nir_flt(&b, clipdist[plane], nir_imm_float(&b, 0.0)); discard = nir_intrinsic_instr_create(b.shader, nir_intrinsic_discard_if); discard->src[0] = nir_src_for_ssa(cond); nir_builder_instr_insert(&b, &discard->instr); b.shader->info.fs.uses_discard = true; } } nir_metadata_preserve(impl, nir_metadata_dominance); } /* insert conditional kill based on interpolated CLIPDIST */ bool nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables) { nir_variable *in[2]; int maxloc = -1; if (!ucp_enables) return false; nir_foreach_variable(var, &shader->inputs) { int loc = var->data.driver_location; /* keep track of last used driver-location.. we'll be * appending CLIP_DIST0/CLIP_DIST1 after last existing * input: */ maxloc = MAX2(maxloc, loc); } /* The shader won't normally have CLIPDIST inputs, so we * must add our own: */ /* insert CLIPDIST outputs: */ if (ucp_enables & 0x0f) in[0] = create_clipdist_var(shader, ++maxloc, false, VARYING_SLOT_CLIP_DIST0); if (ucp_enables & 0xf0) in[1] = create_clipdist_var(shader, ++maxloc, false, VARYING_SLOT_CLIP_DIST1); nir_foreach_function(function, shader) { if (!strcmp(function->name, "main")) lower_clip_fs(function->impl, ucp_enables, in); } return true; }