#include "nir.h"
#include "nir_builder.h"
+#include "nir_format_convert.h"
static void
project_src(nir_builder *b, nir_tex_instr *tex)
{
/* Find the projector in the srcs list, if present. */
- unsigned proj_index;
- for (proj_index = 0; proj_index < tex->num_srcs; proj_index++) {
- if (tex->src[proj_index].src_type == nir_tex_src_projector)
- break;
- }
- if (proj_index == tex->num_srcs)
+ int proj_index = nir_tex_instr_src_index(tex, nir_tex_src_projector);
+ if (proj_index < 0)
return;
b->cursor = nir_before_instr(&tex->instr);
for (unsigned i = 0; i < tex->num_srcs; i++) {
switch (tex->src[i].src_type) {
case nir_tex_src_coord:
- case nir_tex_src_comparitor:
+ case nir_tex_src_comparator:
break;
default:
continue;
nir_src_for_ssa(projected));
}
- /* Now move the later tex sources down the array so that the projector
- * disappears.
- */
- nir_instr_rewrite_src(&tex->instr, &tex->src[proj_index].src,
- NIR_SRC_INIT);
- for (unsigned i = proj_index + 1; i < tex->num_srcs; i++) {
- tex->src[i-1].src_type = tex->src[i].src_type;
- nir_instr_move_src(&tex->instr, &tex->src[i-1].src, &tex->src[i].src);
- }
- tex->num_srcs--;
+ nir_tex_instr_remove_src(tex, proj_index);
}
static nir_ssa_def *
{
b->cursor = nir_before_instr(&tex->instr);
- /* RECT textures should not be array: */
- assert(!tex->is_array);
-
nir_tex_instr *txs;
- txs = nir_tex_instr_create(b->shader, 1);
+ 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)
+ num_srcs++;
+ }
+
+ txs = nir_tex_instr_create(b->shader, num_srcs);
txs->op = nir_texop_txs;
- txs->sampler_dim = GLSL_SAMPLER_DIM_RECT;
+ 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;
- /* only single src, the lod: */
- txs->src[0].src = nir_src_for_ssa(nir_imm_int(b, 0));
- txs->src[0].src_type = nir_tex_src_lod;
+ 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) {
+ 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, 2, 32, NULL);
+ 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_i2f(b, &txs->dest.ssa);
+ 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)
+ 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) {
+ 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);
+}
+
+static bool
+lower_offset(nir_builder *b, nir_tex_instr *tex)
+{
+ int offset_index = nir_tex_instr_src_index(tex, nir_tex_src_offset);
+ if (offset_index < 0)
+ return false;
+
+ int coord_index = nir_tex_instr_src_index(tex, nir_tex_src_coord);
+ assert(coord_index >= 0);
+
+ assert(tex->src[offset_index].src.is_ssa);
+ assert(tex->src[coord_index].src.is_ssa);
+ nir_ssa_def *offset = tex->src[offset_index].src.ssa;
+ nir_ssa_def *coord = tex->src[coord_index].src.ssa;
+
+ b->cursor = nir_before_instr(&tex->instr);
+
+ nir_ssa_def *offset_coord;
+ if (nir_tex_instr_src_type(tex, coord_index) == nir_type_float) {
+ 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 *scale = nir_frcp(b, txs);
+
+ offset_coord = nir_fadd(b, coord,
+ nir_fmul(b,
+ nir_i2f32(b, offset),
+ scale));
+ }
+ } else {
+ offset_coord = nir_iadd(b, coord, offset);
+ }
+
+ if (tex->is_array) {
+ /* The offset is not applied to the array index */
+ if (tex->coord_components == 2) {
+ offset_coord = nir_vec2(b, nir_channel(b, offset_coord, 0),
+ nir_channel(b, coord, 1));
+ } else if (tex->coord_components == 3) {
+ offset_coord = nir_vec3(b, nir_channel(b, offset_coord, 0),
+ nir_channel(b, offset_coord, 1),
+ nir_channel(b, coord, 2));
+ } else {
+ unreachable("Invalid number of components");
+ }
+ }
+
+ nir_instr_rewrite_src(&tex->instr, &tex->src[coord_index].src,
+ nir_src_for_ssa(offset_coord));
+
+ nir_tex_instr_remove_src(tex, offset_index);
+
+ return true;
}
static void
tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
}
+static void
+lower_implicit_lod(nir_builder *b, nir_tex_instr *tex)
+{
+ assert(tex->op == nir_texop_tex || tex->op == nir_texop_txb);
+ assert(nir_tex_instr_src_index(tex, nir_tex_src_lod) < 0);
+ assert(nir_tex_instr_src_index(tex, nir_tex_src_ddx) < 0);
+ assert(nir_tex_instr_src_index(tex, nir_tex_src_ddy) < 0);
+
+ b->cursor = nir_before_instr(&tex->instr);
+
+ nir_ssa_def *lod = get_texture_lod(b, tex);
+
+ int bias_idx = nir_tex_instr_src_index(tex, nir_tex_src_bias);
+ if (bias_idx >= 0) {
+ /* If we have a bias, add it in */
+ lod = nir_fadd(b, lod, nir_ssa_for_src(b, tex->src[bias_idx].src, 1));
+ nir_tex_instr_remove_src(tex, bias_idx);
+ }
+
+ int min_lod_idx = nir_tex_instr_src_index(tex, nir_tex_src_min_lod);
+ if (min_lod_idx >= 0) {
+ /* If we have a minimum LOD, clamp LOD accordingly */
+ lod = nir_fmax(b, lod, nir_ssa_for_src(b, tex->src[min_lod_idx].src, 1));
+ nir_tex_instr_remove_src(tex, min_lod_idx);
+ }
+
+ nir_tex_instr_add_src(tex, nir_tex_src_lod, nir_src_for_ssa(lod));
+ tex->op = nir_texop_txl;
+}
+
static nir_ssa_def *
sample_plane(nir_builder *b, nir_tex_instr *tex, int plane)
{
assert(tex->op == nir_texop_tex);
assert(tex->coord_components == 2);
- nir_tex_instr *plane_tex = nir_tex_instr_create(b->shader, 2);
- nir_src_copy(&plane_tex->src[0].src, &tex->src[0].src, plane_tex);
- plane_tex->src[0].src_type = nir_tex_src_coord;
- plane_tex->src[1].src = nir_src_for_ssa(nir_imm_int(b, plane));
- plane_tex->src[1].src_type = nir_tex_src_plane;
+ nir_tex_instr *plane_tex =
+ nir_tex_instr_create(b->shader, tex->num_srcs + 1);
+ for (unsigned i = 0; i < tex->num_srcs; i++) {
+ nir_src_copy(&plane_tex->src[i].src, &tex->src[i].src, plane_tex);
+ plane_tex->src[i].src_type = tex->src[i].src_type;
+ }
+ plane_tex->src[tex->num_srcs].src = nir_src_for_ssa(nir_imm_int(b, plane));
+ plane_tex->src[tex->num_srcs].src_type = nir_tex_src_plane;
plane_tex->op = nir_texop_tex;
- plane_tex->sampler_dim = 2;
+ plane_tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
plane_tex->dest_type = nir_type_float;
plane_tex->coord_components = 2;
plane_tex->texture_index = tex->texture_index;
- plane_tex->texture = (nir_deref_var *)
- nir_copy_deref(plane_tex, &tex->texture->deref);
plane_tex->sampler_index = tex->sampler_index;
- plane_tex->sampler = (nir_deref_var *)
- nir_copy_deref(plane_tex, &tex->sampler->deref);
nir_ssa_dest_init(&plane_tex->instr, &plane_tex->dest, 4, 32, NULL);
static void
convert_yuv_to_rgb(nir_builder *b, nir_tex_instr *tex,
- nir_ssa_def *y, nir_ssa_def *u, nir_ssa_def *v)
+ nir_ssa_def *y, nir_ssa_def *u, nir_ssa_def *v,
+ nir_ssa_def *a)
{
nir_const_value m[3] = {
{ .f32 = { 1.0f, 0.0f, 1.59602678f, 0.0f } },
nir_ssa_def *yuv =
nir_vec4(b,
nir_fmul(b, nir_imm_float(b, 1.16438356f),
- nir_fadd(b, y, nir_imm_float(b, -0.0625f))),
- nir_channel(b, nir_fadd(b, u, nir_imm_float(b, -0.5f)), 0),
- nir_channel(b, nir_fadd(b, v, nir_imm_float(b, -0.5f)), 0),
+ 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_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, nir_imm_float(b, 1.0f));
+ nir_ssa_def *result = nir_vec4(b, red, green, blue, a);
nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(result));
}
convert_yuv_to_rgb(b, tex,
nir_channel(b, y, 0),
nir_channel(b, uv, 0),
- nir_channel(b, uv, 1));
+ nir_channel(b, uv, 1),
+ nir_imm_float(b, 1.0f));
}
static void
convert_yuv_to_rgb(b, tex,
nir_channel(b, y, 0),
nir_channel(b, u, 0),
- nir_channel(b, v, 0));
+ nir_channel(b, v, 0),
+ nir_imm_float(b, 1.0f));
}
static void
convert_yuv_to_rgb(b, tex,
nir_channel(b, y, 0),
nir_channel(b, xuxv, 1),
- nir_channel(b, xuxv, 3));
+ nir_channel(b, xuxv, 3),
+ nir_imm_float(b, 1.0f));
+}
+
+static void
+lower_xy_uxvx_external(nir_builder *b, nir_tex_instr *tex)
+{
+ b->cursor = nir_after_instr(&tex->instr);
+
+ nir_ssa_def *y = sample_plane(b, tex, 0);
+ nir_ssa_def *uxvx = sample_plane(b, tex, 1);
+
+ convert_yuv_to_rgb(b, tex,
+ nir_channel(b, y, 1),
+ nir_channel(b, uxvx, 0),
+ nir_channel(b, uxvx, 2),
+ nir_imm_float(b, 1.0f));
+}
+
+static void
+lower_ayuv_external(nir_builder *b, nir_tex_instr *tex)
+{
+ b->cursor = nir_after_instr(&tex->instr);
+
+ nir_ssa_def *ayuv = sample_plane(b, tex, 0);
+
+ convert_yuv_to_rgb(b, tex,
+ nir_channel(b, ayuv, 2),
+ nir_channel(b, ayuv, 1),
+ nir_channel(b, ayuv, 0),
+ nir_channel(b, ayuv, 3));
+}
+
+/*
+ * Converts a nir_texop_txd instruction to nir_texop_txl with the given lod
+ * computed from the gradients.
+ */
+static void
+replace_gradient_with_lod(nir_builder *b, nir_ssa_def *lod, nir_tex_instr *tex)
+{
+ assert(tex->op == nir_texop_txd);
+
+ nir_tex_instr_remove_src(tex, nir_tex_instr_src_index(tex, nir_tex_src_ddx));
+ nir_tex_instr_remove_src(tex, nir_tex_instr_src_index(tex, nir_tex_src_ddy));
+
+ int min_lod_idx = nir_tex_instr_src_index(tex, nir_tex_src_min_lod);
+ if (min_lod_idx >= 0) {
+ /* If we have a minimum LOD, clamp LOD accordingly */
+ lod = nir_fmax(b, lod, nir_ssa_for_src(b, tex->src[min_lod_idx].src, 1));
+ nir_tex_instr_remove_src(tex, min_lod_idx);
+ }
+
+ nir_tex_instr_add_src(tex, nir_tex_src_lod, nir_src_for_ssa(lod));
+ tex->op = nir_texop_txl;
+}
+
+static void
+lower_gradient_cube_map(nir_builder *b, nir_tex_instr *tex)
+{
+ assert(tex->sampler_dim == GLSL_SAMPLER_DIM_CUBE);
+ assert(tex->op == nir_texop_txd);
+ 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);
+
+ /* Cubemap texture lookups first generate a texture coordinate normalized
+ * to [-1, 1] on the appropiate face. The appropiate face is determined
+ * by which component has largest magnitude and its sign. The texture
+ * coordinate is the quotient of the remaining texture coordinates against
+ * that absolute value of the component of largest magnitude. This
+ * division requires that the computing of the derivative of the texel
+ * coordinate must use the quotient rule. The high level GLSL code is as
+ * follows:
+ *
+ * Step 1: selection
+ *
+ * vec3 abs_p, Q, dQdx, dQdy;
+ * abs_p = abs(ir->coordinate);
+ * if (abs_p.x >= max(abs_p.y, abs_p.z)) {
+ * Q = ir->coordinate.yzx;
+ * dQdx = ir->lod_info.grad.dPdx.yzx;
+ * dQdy = ir->lod_info.grad.dPdy.yzx;
+ * }
+ * if (abs_p.y >= max(abs_p.x, abs_p.z)) {
+ * Q = ir->coordinate.xzy;
+ * dQdx = ir->lod_info.grad.dPdx.xzy;
+ * dQdy = ir->lod_info.grad.dPdy.xzy;
+ * }
+ * if (abs_p.z >= max(abs_p.x, abs_p.y)) {
+ * Q = ir->coordinate;
+ * dQdx = ir->lod_info.grad.dPdx;
+ * dQdy = ir->lod_info.grad.dPdy;
+ * }
+ *
+ * Step 2: use quotient rule to compute derivative. The normalized to
+ * [-1, 1] texel coordinate is given by Q.xy / (sign(Q.z) * Q.z). We are
+ * only concerned with the magnitudes of the derivatives whose values are
+ * not affected by the sign. We drop the sign from the computation.
+ *
+ * vec2 dx, dy;
+ * float recip;
+ *
+ * recip = 1.0 / Q.z;
+ * dx = recip * ( dQdx.xy - Q.xy * (dQdx.z * recip) );
+ * dy = recip * ( dQdy.xy - Q.xy * (dQdy.z * recip) );
+ *
+ * Step 3: compute LOD. At this point we have the derivatives of the
+ * texture coordinates normalized to [-1,1]. We take the LOD to be
+ * result = log2(max(sqrt(dot(dx, dx)), sqrt(dy, dy)) * 0.5 * L)
+ * = -1.0 + log2(max(sqrt(dot(dx, dx)), sqrt(dy, dy)) * L)
+ * = -1.0 + log2(sqrt(max(dot(dx, dx), dot(dy,dy))) * L)
+ * = -1.0 + log2(sqrt(L * L * max(dot(dx, dx), dot(dy,dy))))
+ * = -1.0 + 0.5 * log2(L * L * max(dot(dx, dx), dot(dy,dy)))
+ * where L is the dimension of the cubemap. The code is:
+ *
+ * float M, result;
+ * M = max(dot(dx, dx), dot(dy, dy));
+ * L = textureSize(sampler, 0).x;
+ * result = -1.0 + 0.5 * log2(L * L * M);
+ */
+
+ /* coordinate */
+ nir_ssa_def *p =
+ tex->src[nir_tex_instr_src_index(tex, nir_tex_src_coord)].src.ssa;
+
+ /* unmodified dPdx, dPdy values */
+ nir_ssa_def *dPdx =
+ tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddx)].src.ssa;
+ nir_ssa_def *dPdy =
+ tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddy)].src.ssa;
+
+ nir_ssa_def *abs_p = nir_fabs(b, p);
+ nir_ssa_def *abs_p_x = nir_channel(b, abs_p, 0);
+ nir_ssa_def *abs_p_y = nir_channel(b, abs_p, 1);
+ nir_ssa_def *abs_p_z = nir_channel(b, abs_p, 2);
+
+ /* 1. compute selector */
+ nir_ssa_def *Q, *dQdx, *dQdy;
+
+ nir_ssa_def *cond_z = nir_fge(b, abs_p_z, nir_fmax(b, abs_p_x, abs_p_y));
+ nir_ssa_def *cond_y = nir_fge(b, abs_p_y, nir_fmax(b, abs_p_x, abs_p_z));
+
+ unsigned yzx[3] = { 1, 2, 0 };
+ unsigned xzy[3] = { 0, 2, 1 };
+
+ 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)));
+
+ 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)));
+
+ 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)));
+
+ /* 2. quotient rule */
+
+ /* tmp = Q.xy * recip;
+ * dx = recip * ( dQdx.xy - (tmp * dQdx.z) );
+ * dy = recip * ( dQdy.xy - (tmp * dQdy.z) );
+ */
+ nir_ssa_def *rcp_Q_z = nir_frcp(b, nir_channel(b, Q, 2));
+
+ nir_ssa_def *Q_xy = nir_channels(b, Q, 0x3);
+ nir_ssa_def *tmp = nir_fmul(b, Q_xy, rcp_Q_z);
+
+ nir_ssa_def *dQdx_xy = nir_channels(b, dQdx, 0x3);
+ nir_ssa_def *dQdx_z = nir_channel(b, dQdx, 2);
+ nir_ssa_def *dx =
+ nir_fmul(b, rcp_Q_z, nir_fsub(b, dQdx_xy, nir_fmul(b, tmp, dQdx_z)));
+
+ nir_ssa_def *dQdy_xy = nir_channels(b, dQdy, 0x3);
+ nir_ssa_def *dQdy_z = nir_channel(b, dQdy, 2);
+ nir_ssa_def *dy =
+ nir_fmul(b, rcp_Q_z, nir_fsub(b, dQdy_xy, nir_fmul(b, tmp, dQdy_z)));
+
+ /* M = max(dot(dx, dx), dot(dy, dy)); */
+ nir_ssa_def *M = nir_fmax(b, nir_fdot(b, dx, dx), nir_fdot(b, dy, dy));
+
+ /* size has textureSize() of LOD 0 */
+ nir_ssa_def *L = nir_channel(b, size, 0);
+
+ /* lod = -1.0 + 0.5 * log2(L * L * M); */
+ nir_ssa_def *lod =
+ nir_fadd(b,
+ nir_imm_float(b, -1.0f),
+ nir_fmul(b,
+ nir_imm_float(b, 0.5f),
+ nir_flog2(b, nir_fmul(b, L, nir_fmul(b, L, M)))));
+
+ /* 3. Replace the gradient instruction with an equivalent lod instruction */
+ replace_gradient_with_lod(b, lod, tex);
+}
+
+static void
+lower_gradient(nir_builder *b, nir_tex_instr *tex)
+{
+ /* Cubes are more complicated and have their own function */
+ if (tex->sampler_dim == GLSL_SAMPLER_DIM_CUBE) {
+ lower_gradient_cube_map(b, tex);
+ return;
+ }
+
+ assert(tex->sampler_dim != GLSL_SAMPLER_DIM_CUBE);
+ assert(tex->op == nir_texop_txd);
+ assert(tex->dest.is_ssa);
+
+ /* Use textureSize() to get the width and height of LOD 0 */
+ unsigned component_mask;
+ switch (tex->sampler_dim) {
+ case GLSL_SAMPLER_DIM_3D:
+ component_mask = 7;
+ break;
+ case GLSL_SAMPLER_DIM_1D:
+ component_mask = 1;
+ break;
+ default:
+ component_mask = 3;
+ break;
+ }
+
+ nir_ssa_def *size =
+ nir_channels(b, 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
+ * GL 3.0 spec; we want u'(x,y), which is w_t * s'(x,y).
+ */
+ nir_ssa_def *ddx =
+ tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddx)].src.ssa;
+ nir_ssa_def *ddy =
+ tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddy)].src.ssa;
+
+ nir_ssa_def *dPdx = nir_fmul(b, ddx, size);
+ nir_ssa_def *dPdy = nir_fmul(b, ddy, size);
+
+ nir_ssa_def *rho;
+ if (dPdx->num_components == 1) {
+ rho = nir_fmax(b, nir_fabs(b, dPdx), nir_fabs(b, dPdy));
+ } else {
+ rho = nir_fmax(b,
+ nir_fsqrt(b, nir_fdot(b, dPdx, dPdx)),
+ nir_fsqrt(b, nir_fdot(b, dPdy, dPdy)));
+ }
+
+ /* lod = log2(rho). We're ignoring GL state biases for now. */
+ nir_ssa_def *lod = nir_flog2(b, rho);
+
+ /* Replace the gradient instruction with an equivalent lod instruction */
+ replace_gradient_with_lod(b, lod, tex);
}
static void
if (swizzle[0] < 4 && swizzle[1] < 4 &&
swizzle[2] < 4 && swizzle[3] < 4) {
unsigned swiz[4] = { swizzle[0], swizzle[1], swizzle[2], swizzle[3] };
- /* We have no 0's or 1's, just emit a swizzling MOV */
+ /* We have no 0s or 1s, just emit a swizzling MOV */
swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4, false);
} else {
nir_ssa_def *srcs[4];
b->cursor = nir_after_instr(&tex->instr);
- static const unsigned swiz[4] = {0, 1, 2, 0};
- nir_ssa_def *comp = nir_swizzle(b, &tex->dest.ssa, swiz, 3, true);
-
- /* Formula is:
- * (comp <= 0.04045) ?
- * (comp / 12.92) :
- * pow((comp + 0.055) / 1.055, 2.4)
- */
- nir_ssa_def *low = nir_fmul(b, comp, nir_imm_float(b, 1.0 / 12.92));
- nir_ssa_def *high = nir_fpow(b,
- nir_fmul(b,
- nir_fadd(b,
- comp,
- nir_imm_float(b, 0.055)),
- nir_imm_float(b, 1.0 / 1.055)),
- nir_imm_float(b, 2.4));
- nir_ssa_def *cond = nir_fge(b, nir_imm_float(b, 0.04045), comp);
- nir_ssa_def *rgb = nir_bcsel(b, cond, low, high);
+ nir_ssa_def *rgb =
+ nir_format_srgb_to_linear(b, nir_channels(b, &tex->dest.ssa, 0x7));
/* alpha is untouched: */
nir_ssa_def *result = nir_vec4(b,
progress = true;
}
+ if ((tex->op == nir_texop_txf && options->lower_txf_offset) ||
+ (sat_mask && nir_tex_instr_src_index(tex, nir_tex_src_coord) >= 0) ||
+ (tex->sampler_dim == GLSL_SAMPLER_DIM_RECT &&
+ options->lower_rect_offset)) {
+ progress = lower_offset(b, tex) || progress;
+ }
+
if ((tex->sampler_dim == GLSL_SAMPLER_DIM_RECT) && options->lower_rect) {
lower_rect(b, tex);
progress = true;
progress = true;
}
+ if ((1 << tex->texture_index) & options->lower_xy_uxvx_external) {
+ lower_xy_uxvx_external(b, tex);
+ progress = true;
+ }
+
+ if ((1 << tex->texture_index) & options->lower_ayuv_external) {
+ lower_ayuv_external(b, tex);
+ progress = true;
+ }
if (sat_mask) {
saturate_src(b, tex, sat_mask);
linearize_srgb_result(b, tex);
progress = true;
}
+
+ const bool has_min_lod =
+ nir_tex_instr_src_index(tex, nir_tex_src_min_lod) >= 0;
+ const bool has_offset =
+ nir_tex_instr_src_index(tex, nir_tex_src_offset) >= 0;
+
+ if (tex->op == nir_texop_txb && tex->is_shadow && has_min_lod &&
+ options->lower_txb_shadow_clamp) {
+ lower_implicit_lod(b, tex);
+ progress = true;
+ }
+
+ if (tex->op == nir_texop_txd &&
+ (options->lower_txd ||
+ (options->lower_txd_shadow && tex->is_shadow) ||
+ (options->lower_txd_shadow_clamp && tex->is_shadow && has_min_lod) ||
+ (options->lower_txd_offset_clamp && has_offset && has_min_lod) ||
+ (options->lower_txd_cube_map &&
+ tex->sampler_dim == GLSL_SAMPLER_DIM_CUBE))) {
+ lower_gradient(b, tex);
+ progress = true;
+ continue;
+ }
+
+ /* TXF, TXS and TXL require a LOD but not everything we implement using those
+ * three opcodes provides one. Provide a default LOD of 0.
+ */
+ if ((nir_tex_instr_src_index(tex, nir_tex_src_lod) == -1) &&
+ (tex->op == nir_texop_txf || tex->op == nir_texop_txs ||
+ tex->op == nir_texop_txl || tex->op == nir_texop_query_levels ||
+ (tex->op == nir_texop_tex &&
+ b->shader->info.stage != MESA_SHADER_FRAGMENT))) {
+ 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)));
+ progress = true;
+ continue;
+ }
}
return progress;
projects / mesa.git / blobdiff