Home | History | Annotate | Download | only in nir
      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