src/compiler/nir/nir_lower_tex.c

   1 /*
   2  * Copyright © 2015 Broadcom
   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
  24 /*
  25  * This lowering pass supports (as configured via nir_lower_tex_options)
  26  * various texture related conversions:
  27  *   + texture projector lowering: converts the coordinate division for
  28  *     texture projection to be done in ALU instructions instead of
  29  *     asking the texture operation to do so.
  30  *   + lowering RECT: converts the un-normalized RECT texture coordinates
  31  *     to normalized coordinates with txs plus ALU instructions
  32  *   + saturate s/t/r coords: to emulate certain texture clamp/wrap modes,
  33  *     inserts instructions to clamp specified coordinates to [0.0, 1.0].
  34  *     Note that this automatically triggers texture projector lowering if
  35  *     needed, since clamping must happen after projector lowering.
  36  */
  37
  38 #include "nir.h"
  39 #include "nir_builder.h"
  40
  41 static void
  42 project_src(nir_builder *b, nir_tex_instr *tex)
  43 {
  44    /* Find the projector in the srcs list, if present. */
  45    unsigned proj_index;
  46    for (proj_index = 0; proj_index < tex->num_srcs; proj_index++) {
  47       if (tex->src[proj_index].src_type == nir_tex_src_projector)
  48          break;
  49    }
  50    if (proj_index == tex->num_srcs)
  51       return;
  52
  53    b->cursor = nir_before_instr(&tex->instr);
  54
  55    nir_ssa_def *inv_proj =
  56       nir_frcp(b, nir_ssa_for_src(b, tex->src[proj_index].src, 1));
  57
  58    /* Walk through the sources projecting the arguments. */
  59    for (unsigned i = 0; i < tex->num_srcs; i++) {
  60       switch (tex->src[i].src_type) {
  61       case nir_tex_src_coord:
  62       case nir_tex_src_comparitor:
  63          break;
  64       default:
  65          continue;
  66       }
  67       nir_ssa_def *unprojected =
  68          nir_ssa_for_src(b, tex->src[i].src, nir_tex_instr_src_size(tex, i));
  69       nir_ssa_def *projected = nir_fmul(b, unprojected, inv_proj);
  70
  71       /* Array indices don't get projected, so make an new vector with the
  72        * coordinate's array index untouched.
  73        */
  74       if (tex->is_array && tex->src[i].src_type == nir_tex_src_coord) {
  75          switch (tex->coord_components) {
  76          case 4:
  77             projected = nir_vec4(b,
  78                                  nir_channel(b, projected, 0),
  79                                  nir_channel(b, projected, 1),
  80                                  nir_channel(b, projected, 2),
  81                                  nir_channel(b, unprojected, 3));
  82             break;
  83          case 3:
  84             projected = nir_vec3(b,
  85                                  nir_channel(b, projected, 0),
  86                                  nir_channel(b, projected, 1),
  87                                  nir_channel(b, unprojected, 2));
  88             break;
  89          case 2:
  90             projected = nir_vec2(b,
  91                                  nir_channel(b, projected, 0),
  92                                  nir_channel(b, unprojected, 1));
  93             break;
  94          default:
  95             unreachable("bad texture coord count for array");
  96             break;
  97          }
  98       }
  99
 100       nir_instr_rewrite_src(&tex->instr,
 101                             &tex->src[i].src,
 102                             nir_src_for_ssa(projected));
 103    }
 104
 105    /* Now move the later tex sources down the array so that the projector
 106     * disappears.
 107     */
 108    nir_instr_rewrite_src(&tex->instr, &tex->src[proj_index].src,
 109                          NIR_SRC_INIT);
 110    for (unsigned i = proj_index + 1; i < tex->num_srcs; i++) {
 111       tex->src[i-1].src_type = tex->src[i].src_type;
 112       nir_instr_move_src(&tex->instr, &tex->src[i-1].src, &tex->src[i].src);
 113    }
 114    tex->num_srcs--;
 115 }
 116
 117 static nir_ssa_def *
 118 get_texture_size(nir_builder *b, nir_tex_instr *tex)
 119 {
 120    b->cursor = nir_before_instr(&tex->instr);
 121
 122    /* RECT textures should not be array: */
 123    assert(!tex->is_array);
 124
 125    nir_tex_instr *txs;
 126
 127    txs = nir_tex_instr_create(b->shader, 1);
 128    txs->op = nir_texop_txs;
 129    txs->sampler_dim = GLSL_SAMPLER_DIM_RECT;
 130    txs->texture_index = tex->texture_index;
 131    txs->dest_type = nir_type_int;
 132
 133    /* only single src, the lod: */
 134    txs->src[0].src = nir_src_for_ssa(nir_imm_int(b, 0));
 135    txs->src[0].src_type = nir_tex_src_lod;
 136
 137    nir_ssa_dest_init(&txs->instr, &txs->dest, 2, 32, NULL);
 138    nir_builder_instr_insert(b, &txs->instr);
 139
 140    return nir_i2f(b, &txs->dest.ssa);
 141 }
 142
 143 static void
 144 lower_rect(nir_builder *b, nir_tex_instr *tex)
 145 {
 146    nir_ssa_def *txs = get_texture_size(b, tex);
 147    nir_ssa_def *scale = nir_frcp(b, txs);
 148
 149    /* Walk through the sources normalizing the requested arguments. */
 150    for (unsigned i = 0; i < tex->num_srcs; i++) {
 151       if (tex->src[i].src_type != nir_tex_src_coord)
 152          continue;
 153
 154       nir_ssa_def *coords =
 155          nir_ssa_for_src(b, tex->src[i].src, tex->coord_components);
 156       nir_instr_rewrite_src(&tex->instr,
 157                             &tex->src[i].src,
 158                             nir_src_for_ssa(nir_fmul(b, coords, scale)));
 159    }
 160
 161    tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
 162 }
 163
 164 static void
 165 saturate_src(nir_builder *b, nir_tex_instr *tex, unsigned sat_mask)
 166 {
 167    b->cursor = nir_before_instr(&tex->instr);
 168
 169    /* Walk through the sources saturating the requested arguments. */
 170    for (unsigned i = 0; i < tex->num_srcs; i++) {
 171       if (tex->src[i].src_type != nir_tex_src_coord)
 172          continue;
 173
 174       nir_ssa_def *src =
 175          nir_ssa_for_src(b, tex->src[i].src, tex->coord_components);
 176
 177       /* split src into components: */
 178       nir_ssa_def *comp[4];
 179
 180       assume(tex->coord_components >= 1);
 181
 182       for (unsigned j = 0; j < tex->coord_components; j++)
 183          comp[j] = nir_channel(b, src, j);
 184
 185       /* clamp requested components, array index does not get clamped: */
 186       unsigned ncomp = tex->coord_components;
 187       if (tex->is_array)
 188          ncomp--;
 189
 190       for (unsigned j = 0; j < ncomp; j++) {
 191          if ((1 << j) & sat_mask) {
 192             if (tex->sampler_dim == GLSL_SAMPLER_DIM_RECT) {
 193                /* non-normalized texture coords, so clamp to texture
 194                 * size rather than [0.0, 1.0]
 195                 */
 196                nir_ssa_def *txs = get_texture_size(b, tex);
 197                comp[j] = nir_fmax(b, comp[j], nir_imm_float(b, 0.0));
 198                comp[j] = nir_fmin(b, comp[j], nir_channel(b, txs, j));
 199             } else {
 200                comp[j] = nir_fsat(b, comp[j]);
 201             }
 202          }
 203       }
 204
 205       /* and move the result back into a single vecN: */
 206       src = nir_vec(b, comp, tex->coord_components);
 207
 208       nir_instr_rewrite_src(&tex->instr,
 209                             &tex->src[i].src,
 210                             nir_src_for_ssa(src));
 211    }
 212 }
 213
 214 static nir_ssa_def *
 215 get_zero_or_one(nir_builder *b, nir_alu_type type, uint8_t swizzle_val)
 216 {
 217    nir_const_value v;
 218
 219    memset(&v, 0, sizeof(v));
 220
 221    if (swizzle_val == 4) {
 222       v.u32[0] = v.u32[1] = v.u32[2] = v.u32[3] = 0;
 223    } else {
 224       assert(swizzle_val == 5);
 225       if (type == nir_type_float)
 226          v.f32[0] = v.f32[1] = v.f32[2] = v.f32[3] = 1.0;
 227       else
 228          v.u32[0] = v.u32[1] = v.u32[2] = v.u32[3] = 1;
 229    }
 230
 231    return nir_build_imm(b, 4, 32, v);
 232 }
 233
 234 static void
 235 swizzle_result(nir_builder *b, nir_tex_instr *tex, const uint8_t swizzle[4])
 236 {
 237    assert(tex->dest.is_ssa);
 238
 239    b->cursor = nir_after_instr(&tex->instr);
 240
 241    nir_ssa_def *swizzled;
 242    if (tex->op == nir_texop_tg4) {
 243       if (swizzle[tex->component] < 4) {
 244          /* This one's easy */
 245          tex->component = swizzle[tex->component];
 246          return;
 247       } else {
 248          swizzled = get_zero_or_one(b, tex->dest_type, swizzle[tex->component]);
 249       }
 250    } else {
 251       assert(nir_tex_instr_dest_size(tex) == 4);
 252       if (swizzle[0] < 4 && swizzle[1] < 4 &&
 253           swizzle[2] < 4 && swizzle[3] < 4) {
 254          unsigned swiz[4] = { swizzle[0], swizzle[1], swizzle[2], swizzle[3] };
 255          /* We have no 0's or 1's, just emit a swizzling MOV */
 256          swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4, false);
 257       } else {
 258          nir_ssa_def *srcs[4];
 259          for (unsigned i = 0; i < 4; i++) {
 260             if (swizzle[i] < 4) {
 261                srcs[i] = nir_channel(b, &tex->dest.ssa, swizzle[i]);
 262             } else {
 263                srcs[i] = get_zero_or_one(b, tex->dest_type, swizzle[i]);
 264             }
 265          }
 266          swizzled = nir_vec(b, srcs, 4);
 267       }
 268    }
 269
 270    nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(swizzled),
 271                                   swizzled->parent_instr);
 272 }
 273
 274 static void
 275 linearize_srgb_result(nir_builder *b, nir_tex_instr *tex)
 276 {
 277    assert(tex->dest.is_ssa);
 278    assert(nir_tex_instr_dest_size(tex) == 4);
 279    assert(nir_alu_type_get_base_type(tex->dest_type) == nir_type_float);
 280
 281    b->cursor = nir_after_instr(&tex->instr);
 282
 283    static const unsigned swiz[4] = {0, 1, 2, 0};
 284    nir_ssa_def *comp = nir_swizzle(b, &tex->dest.ssa, swiz, 3, true);
 285
 286    /* Formula is:
 287     *    (comp <= 0.04045) ?
 288     *          (comp / 12.92) :
 289     *          pow((comp + 0.055) / 1.055, 2.4)
 290     */
 291    nir_ssa_def *low  = nir_fmul(b, comp, nir_imm_float(b, 1.0 / 12.92));
 292    nir_ssa_def *high = nir_fpow(b,
 293                                 nir_fmul(b,
 294                                          nir_fadd(b,
 295                                                   comp,
 296                                                   nir_imm_float(b, 0.055)),
 297                                          nir_imm_float(b, 1.0 / 1.055)),
 298                                 nir_imm_float(b, 2.4));
 299    nir_ssa_def *cond = nir_fge(b, nir_imm_float(b, 0.04045), comp);
 300    nir_ssa_def *rgb  = nir_bcsel(b, cond, low, high);
 301
 302    /* alpha is untouched: */
 303    nir_ssa_def *result = nir_vec4(b,
 304                                   nir_channel(b, rgb, 0),
 305                                   nir_channel(b, rgb, 1),
 306                                   nir_channel(b, rgb, 2),
 307                                   nir_channel(b, &tex->dest.ssa, 3));
 308
 309    nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(result),
 310                                   result->parent_instr);
 311 }
 312
 313 static bool
 314 nir_lower_tex_block(nir_block *block, nir_builder *b,
 315                     const nir_lower_tex_options *options)
 316 {
 317    bool progress = false;
 318
 319    nir_foreach_instr_safe(instr, block) {
 320       if (instr->type != nir_instr_type_tex)
 321          continue;
 322
 323       nir_tex_instr *tex = nir_instr_as_tex(instr);
 324       bool lower_txp = !!(options->lower_txp & (1 << tex->sampler_dim));
 325
 326       /* mask of src coords to saturate (clamp): */
 327       unsigned sat_mask = 0;
 328
 329       if ((1 << tex->sampler_index) & options->saturate_r)
 330          sat_mask |= (1 << 2);    /* .z */
 331       if ((1 << tex->sampler_index) & options->saturate_t)
 332          sat_mask |= (1 << 1);    /* .y */
 333       if ((1 << tex->sampler_index) & options->saturate_s)
 334          sat_mask |= (1 << 0);    /* .x */
 335
 336       /* If we are clamping any coords, we must lower projector first
 337        * as clamping happens *after* projection:
 338        */
 339       if (lower_txp || sat_mask) {
 340          project_src(b, tex);
 341          progress = true;
 342       }
 343
 344       if ((tex->sampler_dim == GLSL_SAMPLER_DIM_RECT) && options->lower_rect) {
 345          lower_rect(b, tex);
 346          progress = true;
 347       }
 348
 349       if (sat_mask) {
 350          saturate_src(b, tex, sat_mask);
 351          progress = true;
 352       }
 353
 354       if (((1 << tex->texture_index) & options->swizzle_result) &&
 355           !nir_tex_instr_is_query(tex) &&
 356           !(tex->is_shadow && tex->is_new_style_shadow)) {
 357          swizzle_result(b, tex, options->swizzles[tex->texture_index]);
 358          progress = true;
 359       }
 360
 361       /* should be after swizzle so we know which channels are rgb: */
 362       if (((1 << tex->texture_index) & options->lower_srgb) &&
 363           !nir_tex_instr_is_query(tex) && !tex->is_shadow) {
 364          linearize_srgb_result(b, tex);
 365          progress = true;
 366       }
 367    }
 368
 369    return progress;
 370 }
 371
 372 static bool
 373 nir_lower_tex_impl(nir_function_impl *impl,
 374                    const nir_lower_tex_options *options)
 375 {
 376    bool progress = false;
 377    nir_builder builder;
 378    nir_builder_init(&builder, impl);
 379
 380    nir_foreach_block(block, impl) {
 381       progress |= nir_lower_tex_block(block, &builder, options);
 382    }
 383
 384    nir_metadata_preserve(impl, nir_metadata_block_index |
 385                                nir_metadata_dominance);
 386    return progress;
 387 }
 388
 389 bool
 390 nir_lower_tex(nir_shader *shader, const nir_lower_tex_options *options)
 391 {
 392    bool progress = false;
 393
 394    nir_foreach_function(function, shader) {
 395       if (function->impl)
 396          progress |= nir_lower_tex_impl(function->impl, options);
 397    }
 398
 399    return progress;
 400 }