On Sep 10, 2015 7:39 PM, "Jason Ekstrand" <<a href="mailto:jason@jlekstrand.net">jason@jlekstrand.net</a>> wrote: > > On Thu, Sep 10, 2015 at 2:39 PM, Rob Clark <<a href="mailto:robdclark@gmail.com">robdclark@gmail.com</a>> wrote: > > From: Rob Clark <<a href="mailto:robclark@freedesktop.org">robclark@freedesktop.org</a>> > > > > So this is basically working as a lowering pass for handling user-clip- > > planes, and frag-shader emulation of CLIPDIST for hardware that needs > > to handle this in the shader. > > > > For user-clip-planes, instructions are inserted to calculate CLIPDIST > > in the VS. And in both cases, discard_if's are inserted in FS to > > handle the clipping. > > > > NOTE: This currently requires a bit of a hack in nir_validate, which > > is unhappy about things like: > > > > decl_var uniform vec4[10] uniform_0 (0, 0) > > decl_var shader_out vec4 out_0 (0, 0) > > decl_var shader_out vec4 clipdist_1 (17, 1) > > decl_var shader_out vec4 clipdist_2 (18, 2) > > decl_overload main returning void > > > > impl main { > > block block_0: > > /* preds: */ > > ... > > /* succs: block_1 */ > > block block_1: > > /* preds: block_0 */ > > ... inserted CLIPDIST calculations ... > > /* succs: block_2 */ > > block block_2: > > } > > > > The thing is, repurposing the end_block and creating a new end_block, > > without having to consider all the different potential successors, > > seems like by far the easiest way to insert code at the end of a > > shader. So probably useful in other cases. (I do something similar > > internally in ir3 for transform-feedback). > > > > Seems like the easiest thing would be to relax the restriction in > > nir_validate, but I'm not sure if this will break other assumptions > > elsewhere. > > Yes it does break assumptions. In particular, it breaks the > assumption that the end-block is empty :-) In all seriousness though, > the idea is that once you jump to the end, you're done. The end block > is the place where returns go. You can't put code after a return > (Ok, yeah, exception handling and destructors etc...). No, I insert a new end_block, so that particular assumption should be safe... I was just wondering if there was some less obvious assumption.. > That said, you're in TGSI land where function inlining and early > return lowering has already happened so there are no early returns. > This means that the end block has exactly one predecessor and you can > put your stuff there. If you want to make it obvious, feel free to > add a nir_end_of_impl constructor for nir_cursor which asserts that > there is exactly one predecessor and calls nir_after_block_before_jump > on that block. That would make it both easy and correct. > > --Jason > > > TODO: sort out hack in nir_validate, reindent, etc. > > > > --- > > src/glsl/Makefile.sources | 1 + > > src/glsl/nir/nir.h | 3 + > > src/glsl/nir/nir_lower_clip.c | 346 ++++++++++++++++++++++++++++++++++++++++++ > > src/glsl/nir/nir_validate.c | 3 +- > > 4 files changed, 351 insertions(+), 2 deletions(-) > > create mode 100644 src/glsl/nir/nir_lower_clip.c > > > > diff --git a/src/glsl/Makefile.sources b/src/glsl/Makefile.sources > > index da7fdf9..5d98b7b 100644 > > --- a/src/glsl/Makefile.sources > > +++ b/src/glsl/Makefile.sources > > @@ -35,6 +35,7 @@ NIR_FILES = \ > > nir/nir_live_variables.c \ > > nir/nir_lower_alu_to_scalar.c \ > > nir/nir_lower_atomics.c \ > > + nir/nir_lower_clip.c \ > > nir/nir_lower_global_vars_to_local.c \ > > nir/nir_lower_load_const_to_scalar.c \ > > nir/nir_lower_locals_to_regs.c \ > > diff --git a/src/glsl/nir/nir.h b/src/glsl/nir/nir.h > > index 2ba7731..8544140 100644 > > --- a/src/glsl/nir/nir.h > > +++ b/src/glsl/nir/nir.h > > @@ -1811,6 +1811,9 @@ void nir_lower_system_values(nir_shader *shader); > > void nir_lower_tex_projector(nir_shader *shader); > > void nir_lower_idiv(nir_shader *shader); > > > > +void nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables); > > +void nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables); > > + > > void nir_lower_atomics(nir_shader *shader); > > void nir_lower_to_source_mods(nir_shader *shader); > > > > diff --git a/src/glsl/nir/nir_lower_clip.c b/src/glsl/nir/nir_lower_clip.c > > new file mode 100644 > > index 0000000..54ebe7b > > --- /dev/null > > +++ b/src/glsl/nir/nir_lower_clip.c > > @@ -0,0 +1,346 @@ > > +/* > > + * 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 <<a href="mailto:robclark@freedesktop.org">robclark@freedesktop.org</a>> > > + */ > > + > > +#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 kill's 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); > > + } else { > > + exec_list_push_tail(&shader->inputs, &var->node); > > + } > > + 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; > > + store->const_index[0] = out->data.driver_location; > > + store->src[0].ssa = nir_vec4(b, val[0], val[1], val[2], val[3]); > > + store->src[0].is_ssa = true; > > + 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; > > + load->const_index[0] = in->data.driver_location; > > + nir_ssa_dest_init(&load->instr, &load->dest, 4, 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); > > +} > > + > > +struct find_output_state { > > + unsigned drvloc; > > + nir_ssa_def *def; > > +}; > > + > > +static bool > > +find_output_in_block(nir_block *block, void *void_state) > > +{ > > + struct find_output_state *state = void_state; > > + nir_foreach_instr(block, instr) { > > + > > + if (instr->type == nir_instr_type_intrinsic) { > > + nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr); > > + if ((intr->intrinsic == nir_intrinsic_store_output) && > > + intr->const_index[0] == state->drvloc) { > > + assert(state->def == NULL); > > + assert(intr->src[0].is_ssa); > > + state->def = intr->src[0].ssa; > > + } > > + } > > + > > +#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 (state->def) > > + return false; > > +#endif > > + } > > + > > + return true; > > +} > > + > > +/* 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) > > +{ > > + struct find_output_state state = { > > + .drvloc = drvloc, > > + }; > > + > > + nir_foreach_overload(shader, overload) { > > + if (overload->impl) { > > + nir_foreach_block_reverse(overload->impl, > > + find_output_in_block, &state); > > + } > > + } > > + > > + return state.def; > > +} > > + > > +/* > > + * VS lowering > > + */ > > + > > +static void > > +lower_clip_vs(nir_function_impl *impl, unsigned ucp_enables, > > + nir_ssa_def *cv, nir_variable **out) > > +{ > > + nir_ssa_def *clipdist[MAX_CLIP_PLANES]; > > + nir_builder b; > > + > > + nir_builder_init(&b, impl); > > + > > + /* Push original end_block to end of body. Since all other > > + * blocks flow into end_block, it is a convenient place to > > + * insert our new clipdist calculations. A new empty > > + * end_block is created: > > + * > > + * NOTE: by default nir_validate is unhappy about formations > > + * such as > > + * > > + * block block_0: > > + * // preds: > > + * ... > > + * // succs: block_1 > > + * block block_1: > > + * // preds: block_0 > > + * ... > > + * // succs: block_2 > > + * block block_2: > > + * ... > > + */ > > + exec_list_push_tail(&impl->body, &impl->end_block->cf_node.node); > > + nir_block *new_end_block = nir_block_create(b.shader); > > + impl->end_block->successors[0] = new_end_block; > > + _mesa_set_add(new_end_block->predecessors, impl->end_block); > > + impl->end_block = new_end_block; > > + b.cursor = nir_after_cf_list(&impl->body); > > + > > + for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) { > > + if (ucp_enables & (1 << plane)) { > > + nir_intrinsic_instr *ucp; > > + > > + /* insert intrinsic to fetch ucp[plane]: */ > > + ucp = nir_intrinsic_instr_create(b.shader, > > + nir_intrinsic_load_user_clip_plane); > > + ucp->num_components = 4; > > + ucp->const_index[0] = plane; > > + nir_ssa_dest_init(&ucp->instr, &ucp->dest, 4, NULL); > > + nir_builder_instr_insert(&b, &ucp->instr); > > + > > + /* calculate clipdist[plane] - dot(ucp, cv): */ > > + clipdist[plane] = nir_fdot3(&b, &ucp->dest.ssa, cv); > > + } else { > > + /* 0.0 == don't-clip == disabled: */ > > + clipdist[plane] = nir_imm_float(&b, 0.0); > > + } > > + } > > + > > + 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); > > +} > > + > > +/* ucp_enables is bitmask of enabled ucp's. Actual ucp values are > > + * passed in to shader via user_clip_plane system-values > > + */ > > +void > > +nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables) > > +{ > > + int clipvertex = -1; > > + int position = -1; > > + int maxloc = -1; > > + nir_ssa_def *cv; > > + nir_variable *out[2]; > > + > > + if (!ucp_enables) > > + return; > > + > > + /* find clipvertex/position outputs: */ > > + foreach_list_typed(nir_variable, var, node, &shader->outputs) { > > + int loc = var->data.driver_location; > > + > > + /* keep track of last used driver-location.. we'll be > > + * appending CLIP_DIST0/CLIP_DIST1 after last existing > > + * output: > > + */ > > + maxloc = MAX2(maxloc, loc); > > + > > + switch (var->data.location) { > > + case VARYING_SLOT_POS: > > + position = loc; > > + break; > > + case VARYING_SLOT_CLIP_VERTEX: > > + clipvertex = loc; > > + 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. > > + */ > > + return; > > + } > > + } > > + > > + if (clipvertex != -1) > > + cv = find_output(shader, clipvertex); > > + else if (position != -1) > > + cv = find_output(shader, position); > > + else > > + return; > > + > > + /* 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); > > + > > + nir_foreach_overload(shader, overload) { > > + if (!strcmp(overload->function->name, "main")) > > + lower_clip_vs(overload->impl, ucp_enables, cv, out); > > + } > > +} > > + > > +/* > > + * 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); > > + } > > + } > > +} > > + > > +/* insert conditional kill based on interpolated CLIPDIST > > + */ > > +void > > +nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables) > > +{ > > + nir_variable *in[2]; > > + int maxloc = -1; > > + > > + if (!ucp_enables) > > + return; > > + > > + foreach_list_typed(nir_variable, var, node, &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_overload(shader, overload) { > > + if (!strcmp(overload->function->name, "main")) > > + lower_clip_fs(overload->impl, ucp_enables, in); > > + } > > +} > > diff --git a/src/glsl/nir/nir_validate.c b/src/glsl/nir/nir_validate.c > > index 9938c0e..f682575 100644 > > --- a/src/glsl/nir/nir_validate.c > > +++ b/src/glsl/nir/nir_validate.c > > @@ -667,8 +667,7 @@ validate_block(nir_block *block, validate_state *state) > > nir_if_first_then_node(if_stmt)); > > assert(&block->successors[1]->cf_node == > > nir_if_first_else_node(if_stmt)); > > - } else { > > - assert(next->type == nir_cf_node_loop); > > + } else if (next->type == nir_cf_node_loop) { > > nir_loop *loop = nir_cf_node_as_loop(next); > > assert(&block->successors[0]->cf_node == > > nir_loop_first_cf_node(loop)); > > -- > > 2.4.3 > > > > _______________________________________________ > > mesa-dev mailing list > > <a href="mailto:mesa-dev@lists.freedesktop.org">mesa-dev@lists.freedesktop.org</a> > > <a href="http://lists.freedesktop.org/mailman/listinfo/mesa-dev">http://lists.freedesktop.org/mailman/listinfo/mesa-dev</a>