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 FROM,
     20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     21  * SOFTWARE.
     22  */
     23 
     24 #include "nir.h"
     25 #include "nir_builder.h"
     26 
     27 /* Lower glBitmap().
     28  *
     29  * This is based on the logic in st_get_bitmap_shader() in TGSI compiler.
     30  * From st_cb_bitmap.c:
     31  *
     32  *    glBitmaps are drawn as textured quads.  The user's bitmap pattern
     33  *    is stored in a texture image.  An alpha8 texture format is used.
     34  *    The fragment shader samples a bit (texel) from the texture, then
     35  *    discards the fragment if the bit is off.
     36  *
     37  *    Note that we actually store the inverse image of the bitmap to
     38  *    simplify the fragment program.  An "on" bit gets stored as texel=0x0
     39  *    and an "off" bit is stored as texel=0xff.  Then we kill the
     40  *    fragment if the negated texel value is less than zero.
     41  *
     42  * Note that the texture format will be, according to what driver supports,
     43  * in order of preference (with swizzle):
     44  *
     45  *    I8_UNORM - .xxxx
     46  *    A8_UNORM - .000x
     47  *    L8_UNORM - .xxx1
     48  *
     49  * If L8_UNORM, options->swizzle_xxxx is true.  Otherwise we can just use
     50  * the .w comp.
     51  *
     52  * Run before nir_lower_io.
     53  */
     54 
     55 static nir_variable *
     56 get_texcoord(nir_shader *shader)
     57 {
     58    nir_variable *texcoord = NULL;
     59 
     60    /* find gl_TexCoord, if it exists: */
     61    nir_foreach_variable(var, &shader->inputs) {
     62       if (var->data.location == VARYING_SLOT_TEX0) {
     63          texcoord = var;
     64          break;
     65       }
     66    }
     67 
     68    /* otherwise create it: */
     69    if (texcoord == NULL) {
     70       texcoord = nir_variable_create(shader,
     71                                      nir_var_shader_in,
     72                                      glsl_vec4_type(),
     73                                      "gl_TexCoord");
     74       texcoord->data.location = VARYING_SLOT_TEX0;
     75    }
     76 
     77    return texcoord;
     78 }
     79 
     80 static void
     81 lower_bitmap(nir_shader *shader, nir_builder *b,
     82              const nir_lower_bitmap_options *options)
     83 {
     84    nir_ssa_def *texcoord;
     85    nir_tex_instr *tex;
     86    nir_ssa_def *cond;
     87    nir_intrinsic_instr *discard;
     88 
     89    texcoord = nir_load_var(b, get_texcoord(shader));
     90 
     91    tex = nir_tex_instr_create(shader, 1);
     92    tex->op = nir_texop_tex;
     93    tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
     94    tex->coord_components = 2;
     95    tex->sampler_index = options->sampler;
     96    tex->texture_index = options->sampler;
     97    tex->dest_type = nir_type_float;
     98    tex->src[0].src_type = nir_tex_src_coord;
     99    tex->src[0].src = nir_src_for_ssa(texcoord);
    100 
    101    nir_ssa_dest_init(&tex->instr, &tex->dest, 4, 32, NULL);
    102    nir_builder_instr_insert(b, &tex->instr);
    103 
    104    /* kill if tex != 0.0.. take .x or .w channel according to format: */
    105    cond = nir_f2b(b, nir_channel(b, &tex->dest.ssa,
    106                   options->swizzle_xxxx ? 0 : 3));
    107 
    108    discard = nir_intrinsic_instr_create(shader, nir_intrinsic_discard_if);
    109    discard->src[0] = nir_src_for_ssa(cond);
    110    nir_builder_instr_insert(b, &discard->instr);
    111 
    112    shader->info->fs.uses_discard = true;
    113 }
    114 
    115 static void
    116 lower_bitmap_impl(nir_function_impl *impl,
    117                   const nir_lower_bitmap_options *options)
    118 {
    119    nir_builder b;
    120 
    121    nir_builder_init(&b, impl);
    122    b.cursor = nir_before_cf_list(&impl->body);
    123 
    124    lower_bitmap(impl->function->shader, &b, options);
    125 
    126    nir_metadata_preserve(impl, nir_metadata_block_index |
    127                                nir_metadata_dominance);
    128 }
    129 
    130 void
    131 nir_lower_bitmap(nir_shader *shader,
    132                  const nir_lower_bitmap_options *options)
    133 {
    134    assert(shader->stage == MESA_SHADER_FRAGMENT);
    135 
    136    lower_bitmap_impl(nir_shader_get_entrypoint(shader), options);
    137 }
    138