#include "nir.h"
#include "nir_builder.h"
+#include "nir_builtin_builder.h"
#include "nir_format_convert.h"
-static void
+static bool
project_src(nir_builder *b, nir_tex_instr *tex)
{
/* Find the projector in the srcs list, if present. */
int proj_index = nir_tex_instr_src_index(tex, nir_tex_src_projector);
if (proj_index < 0)
- return;
+ return false;
b->cursor = nir_before_instr(&tex->instr);
}
nir_tex_instr_remove_src(tex, proj_index);
-}
-
-static nir_ssa_def *
-get_texture_size(nir_builder *b, nir_tex_instr *tex)
-{
- b->cursor = nir_before_instr(&tex->instr);
-
- nir_tex_instr *txs;
-
- unsigned num_srcs = 1; /* One for the LOD */
- for (unsigned i = 0; i < tex->num_srcs; i++) {
- if (tex->src[i].src_type == nir_tex_src_texture_deref ||
- tex->src[i].src_type == nir_tex_src_sampler_deref ||
- tex->src[i].src_type == nir_tex_src_texture_offset ||
- tex->src[i].src_type == nir_tex_src_sampler_offset ||
- tex->src[i].src_type == nir_tex_src_texture_handle ||
- tex->src[i].src_type == nir_tex_src_sampler_handle)
- num_srcs++;
- }
-
- txs = nir_tex_instr_create(b->shader, num_srcs);
- txs->op = nir_texop_txs;
- txs->sampler_dim = tex->sampler_dim;
- txs->is_array = tex->is_array;
- txs->is_shadow = tex->is_shadow;
- txs->is_new_style_shadow = tex->is_new_style_shadow;
- txs->texture_index = tex->texture_index;
- txs->sampler_index = tex->sampler_index;
- txs->dest_type = nir_type_int;
-
- unsigned idx = 0;
- for (unsigned i = 0; i < tex->num_srcs; i++) {
- if (tex->src[i].src_type == nir_tex_src_texture_deref ||
- tex->src[i].src_type == nir_tex_src_sampler_deref ||
- tex->src[i].src_type == nir_tex_src_texture_offset ||
- tex->src[i].src_type == nir_tex_src_sampler_offset ||
- tex->src[i].src_type == nir_tex_src_texture_handle ||
- tex->src[i].src_type == nir_tex_src_sampler_handle) {
- nir_src_copy(&txs->src[idx].src, &tex->src[i].src, txs);
- txs->src[idx].src_type = tex->src[i].src_type;
- idx++;
- }
- }
- /* Add in an LOD because some back-ends require it */
- txs->src[idx].src = nir_src_for_ssa(nir_imm_int(b, 0));
- txs->src[idx].src_type = nir_tex_src_lod;
-
- nir_ssa_dest_init(&txs->instr, &txs->dest,
- nir_tex_instr_dest_size(txs), 32, NULL);
- nir_builder_instr_insert(b, &txs->instr);
-
- return nir_i2f32(b, &txs->dest.ssa);
-}
-
-static nir_ssa_def *
-get_texture_lod(nir_builder *b, nir_tex_instr *tex)
-{
- b->cursor = nir_before_instr(&tex->instr);
-
- nir_tex_instr *tql;
-
- unsigned num_srcs = 0;
- for (unsigned i = 0; i < tex->num_srcs; i++) {
- if (tex->src[i].src_type == nir_tex_src_coord ||
- tex->src[i].src_type == nir_tex_src_texture_deref ||
- tex->src[i].src_type == nir_tex_src_sampler_deref ||
- tex->src[i].src_type == nir_tex_src_texture_offset ||
- tex->src[i].src_type == nir_tex_src_sampler_offset ||
- tex->src[i].src_type == nir_tex_src_texture_handle ||
- tex->src[i].src_type == nir_tex_src_sampler_handle)
- num_srcs++;
- }
-
- tql = nir_tex_instr_create(b->shader, num_srcs);
- tql->op = nir_texop_lod;
- tql->coord_components = tex->coord_components;
- tql->sampler_dim = tex->sampler_dim;
- tql->is_array = tex->is_array;
- tql->is_shadow = tex->is_shadow;
- tql->is_new_style_shadow = tex->is_new_style_shadow;
- tql->texture_index = tex->texture_index;
- tql->sampler_index = tex->sampler_index;
- tql->dest_type = nir_type_float;
-
- unsigned idx = 0;
- for (unsigned i = 0; i < tex->num_srcs; i++) {
- if (tex->src[i].src_type == nir_tex_src_coord ||
- tex->src[i].src_type == nir_tex_src_texture_deref ||
- tex->src[i].src_type == nir_tex_src_sampler_deref ||
- tex->src[i].src_type == nir_tex_src_texture_offset ||
- tex->src[i].src_type == nir_tex_src_sampler_offset ||
- tex->src[i].src_type == nir_tex_src_texture_handle ||
- tex->src[i].src_type == nir_tex_src_sampler_handle) {
- nir_src_copy(&tql->src[idx].src, &tex->src[i].src, tql);
- tql->src[idx].src_type = tex->src[i].src_type;
- idx++;
- }
- }
-
- nir_ssa_dest_init(&tql->instr, &tql->dest, 2, 32, NULL);
- nir_builder_instr_insert(b, &tql->instr);
-
- /* The LOD is the y component of the result */
- return nir_channel(b, &tql->dest.ssa, 1);
+ return true;
}
static bool
if (tex->sampler_dim == GLSL_SAMPLER_DIM_RECT) {
offset_coord = nir_fadd(b, coord, nir_i2f32(b, offset));
} else {
- nir_ssa_def *txs = get_texture_size(b, tex);
+ nir_ssa_def *txs = nir_get_texture_size(b, tex);
nir_ssa_def *scale = nir_frcp(b, txs);
offset_coord = nir_fadd(b, coord,
static void
lower_rect(nir_builder *b, nir_tex_instr *tex)
{
- nir_ssa_def *txs = get_texture_size(b, tex);
+ /* Set the sampler_dim to 2D here so that get_texture_size picks up the
+ * right dimensionality.
+ */
+ tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
+
+ nir_ssa_def *txs = nir_get_texture_size(b, tex);
nir_ssa_def *scale = nir_frcp(b, txs);
/* Walk through the sources normalizing the requested arguments. */
&tex->src[i].src,
nir_src_for_ssa(nir_fmul(b, coords, scale)));
}
-
- tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
}
static void
b->cursor = nir_before_instr(&tex->instr);
- nir_ssa_def *lod = get_texture_lod(b, tex);
+ nir_ssa_def *lod = nir_get_texture_lod(b, tex);
int bias_idx = nir_tex_instr_src_index(tex, nir_tex_src_bias);
if (bias_idx >= 0) {
nir_ssa_def *a)
{
nir_const_value m[3][4] = {
- { { .f32 = 1.0f }, { .f32 = 0.0f }, { .f32 = 1.59602678f }, { .f32 = 0.0f } },
- { { .f32 = 1.0f }, { .f32 = -0.39176229f }, { .f32 = -0.81296764f }, { .f32 = 0.0f } },
- { { .f32 = 1.0f }, { .f32 = 2.01723214f }, { .f32 = 0.0f }, { .f32 = 0.0f } },
+ { { .f32 = 1.16438356f }, { .f32 = 1.16438356f }, { .f32 = 1.16438356f }, { .f32 = 0.0f } },
+ { { .f32 = 0.0f }, { .f32 = -0.39176229f }, { .f32 = 2.01723214f }, { .f32 = 0.0f } },
+ { { .f32 = 1.59602678f }, { .f32 = -0.81296764f }, { .f32 = 0.0f }, { .f32 = 0.0f } },
};
- nir_ssa_def *yuv =
+ nir_ssa_def *offset =
nir_vec4(b,
- nir_fmul(b, nir_imm_float(b, 1.16438356f),
- nir_fadd(b, y, nir_imm_float(b, -16.0f / 255.0f))),
- nir_channel(b, nir_fadd(b, u, nir_imm_float(b, -128.0f / 255.0f)), 0),
- nir_channel(b, nir_fadd(b, v, nir_imm_float(b, -128.0f / 255.0f)), 0),
- nir_imm_float(b, 0.0));
+ nir_imm_float(b, -0.874202214f),
+ nir_imm_float(b, 0.531667820f),
+ nir_imm_float(b, -1.085630787f),
+ a);
- nir_ssa_def *red = nir_fdot4(b, yuv, nir_build_imm(b, 4, 32, m[0]));
- nir_ssa_def *green = nir_fdot4(b, yuv, nir_build_imm(b, 4, 32, m[1]));
- nir_ssa_def *blue = nir_fdot4(b, yuv, nir_build_imm(b, 4, 32, m[2]));
-
- nir_ssa_def *result = nir_vec4(b, red, green, blue, a);
+ nir_ssa_def *result =
+ nir_ffma(b, y, nir_build_imm(b, 4, 32, m[0]),
+ nir_ffma(b, u, nir_build_imm(b, 4, 32, m[1]),
+ nir_ffma(b, v, nir_build_imm(b, 4, 32, m[2]),
+ offset)));
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(result));
}
assert(tex->dest.is_ssa);
/* Use textureSize() to get the width and height of LOD 0 */
- nir_ssa_def *size = get_texture_size(b, tex);
+ nir_ssa_def *size = nir_get_texture_size(b, tex);
/* Cubemap texture lookups first generate a texture coordinate normalized
* to [-1, 1] on the appropiate face. The appropiate face is determined
Q = nir_bcsel(b, cond_z,
p,
nir_bcsel(b, cond_y,
- nir_swizzle(b, p, xzy, 3, false),
- nir_swizzle(b, p, yzx, 3, false)));
+ nir_swizzle(b, p, xzy, 3),
+ nir_swizzle(b, p, yzx, 3)));
dQdx = nir_bcsel(b, cond_z,
dPdx,
nir_bcsel(b, cond_y,
- nir_swizzle(b, dPdx, xzy, 3, false),
- nir_swizzle(b, dPdx, yzx, 3, false)));
+ nir_swizzle(b, dPdx, xzy, 3),
+ nir_swizzle(b, dPdx, yzx, 3)));
dQdy = nir_bcsel(b, cond_z,
dPdy,
nir_bcsel(b, cond_y,
- nir_swizzle(b, dPdy, xzy, 3, false),
- nir_swizzle(b, dPdy, yzx, 3, false)));
+ nir_swizzle(b, dPdy, xzy, 3),
+ nir_swizzle(b, dPdy, yzx, 3)));
/* 2. quotient rule */
}
nir_ssa_def *size =
- nir_channels(b, get_texture_size(b, tex), component_mask);
+ nir_channels(b, nir_get_texture_size(b, tex), component_mask);
/* Scale the gradients by width and height. Effectively, the incoming
* gradients are s'(x,y), t'(x,y), and r'(x,y) from equation 3.19 in the
/* non-normalized texture coords, so clamp to texture
* size rather than [0.0, 1.0]
*/
- nir_ssa_def *txs = get_texture_size(b, tex);
+ nir_ssa_def *txs = nir_get_texture_size(b, tex);
comp[j] = nir_fmax(b, comp[j], nir_imm_float(b, 0.0));
comp[j] = nir_fmin(b, comp[j], nir_channel(b, txs, j));
} else {
assert(nir_tex_instr_dest_size(tex) == 4);
unsigned swiz[4] = { 2, 3, 1, 0 };
- nir_ssa_def *swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4, false);
+ nir_ssa_def *swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4);
nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(swizzled),
swizzled->parent_instr);
swizzle[2] < 4 && swizzle[3] < 4) {
unsigned swiz[4] = { swizzle[0], swizzle[1], swizzle[2], swizzle[3] };
/* We have no 0s or 1s, just emit a swizzling MOV */
- swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4, false);
+ swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4);
} else {
nir_ssa_def *srcs[4];
for (unsigned i = 0; i < 4; i++) {
return true;
}
+static bool
+nir_lower_txs_lod(nir_builder *b, nir_tex_instr *tex)
+{
+ int lod_idx = nir_tex_instr_src_index(tex, nir_tex_src_lod);
+ if (lod_idx < 0 ||
+ (nir_src_is_const(tex->src[lod_idx].src) &&
+ nir_src_as_int(tex->src[lod_idx].src) == 0))
+ return false;
+
+ unsigned dest_size = nir_tex_instr_dest_size(tex);
+
+ b->cursor = nir_before_instr(&tex->instr);
+ nir_ssa_def *lod = nir_ssa_for_src(b, tex->src[lod_idx].src, 1);
+
+ /* Replace the non-0-LOD in the initial TXS operation by a 0-LOD. */
+ nir_instr_rewrite_src(&tex->instr, &tex->src[lod_idx].src,
+ nir_src_for_ssa(nir_imm_int(b, 0)));
+
+ /* TXS(LOD) = max(TXS(0) >> LOD, 1) */
+ b->cursor = nir_after_instr(&tex->instr);
+ nir_ssa_def *minified = nir_imax(b, nir_ushr(b, &tex->dest.ssa, lod),
+ nir_imm_int(b, 1));
+
+ /* Make sure the component encoding the array size (if any) is not
+ * minified.
+ */
+ if (tex->is_array) {
+ nir_ssa_def *comp[3];
+
+ assert(dest_size <= ARRAY_SIZE(comp));
+ for (unsigned i = 0; i < dest_size - 1; i++)
+ comp[i] = nir_channel(b, minified, i);
+
+ comp[dest_size - 1] = nir_channel(b, &tex->dest.ssa, dest_size - 1);
+ minified = nir_vec(b, comp, dest_size);
+ }
+
+ nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(minified),
+ minified->parent_instr);
+ return true;
+}
+
static bool
nir_lower_tex_block(nir_block *block, nir_builder *b,
const nir_lower_tex_options *options)
nir_tex_instr *tex = nir_instr_as_tex(instr);
bool lower_txp = !!(options->lower_txp & (1 << tex->sampler_dim));
+ /* we aren't really going to do the right thing if we haven't
+ * lowered tex/samp derefs yet:
+ */
+ assume(nir_tex_instr_src_index(tex, nir_tex_src_texture_deref) < 0);
+ assume(nir_tex_instr_src_index(tex, nir_tex_src_sampler_deref) < 0);
+
/* mask of src coords to saturate (clamp): */
unsigned sat_mask = 0;
* as clamping happens *after* projection:
*/
if (lower_txp || sat_mask) {
- project_src(b, tex);
- progress = true;
+ progress |= project_src(b, tex);
}
if ((tex->op == nir_texop_txf && options->lower_txf_offset) ||
(tex->op == nir_texop_tex && !shader_supports_implicit_lod))) {
b->cursor = nir_before_instr(&tex->instr);
nir_tex_instr_add_src(tex, nir_tex_src_lod, nir_src_for_ssa(nir_imm_int(b, 0)));
+ if (tex->op == nir_texop_tex && options->lower_tex_without_implicit_lod)
+ tex->op = nir_texop_txl;
progress = true;
continue;
}
+ if (options->lower_txs_lod && tex->op == nir_texop_txs) {
+ progress |= nir_lower_txs_lod(b, tex);
+ continue;
+ }
+
/* has to happen after all the other lowerings as the original tg4 gets
* replaced by 4 tg4 instructions.
*/
projects / mesa.git / blobdiff