fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-06 11:38:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

nir: use nir_build_frag_coord everywhere

Browse source 
nir_build_frag_coord generates the correct sysval loads based on NIR
options. nir_load_frag_coord shouldn't be used directly because drivers
don't have to support it.

v2: RADV can't use it because nir->options isn't set, so use load_pixel_coord.

Reviewed-by: Georg Lehmann <dadschoorse@gmail.com>
Acked-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Reviewed-by: Emma Anholt <emma@anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/41227>
This commit is contained in:
Marek Olšák 2026-04-29 06:41:46 -04:00 • committed by Marge Bot
parent b63a9a8b39
commit f583f6e717
15 changed files with 25 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/amd/common/nir/ac_nir_lower_ps_early.c
View file

@ -432,7 +432,7 @@ lower_ps_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin, void *state)
num_samples));
} else {
/* sample_pos = ffract(frag_coord.xy); */
nir_def_replace(&intrin->def, nir_ffract(b, nir_channels(b, nir_load_frag_coord(b), 0x3)));
nir_def_replace(&intrin->def, nir_ffract(b, nir_build_frag_coord(b, 2)));
}
return true;
case nir_intrinsic_load_sample_id:
@ -505,7 +505,7 @@ lower_ps_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin, void *state)
nir_def *new_fragcoord_xy = nir_u2f32(b, nir_load_pixel_coord(b));
if (!b->shader->info.fs.pixel_center_integer)
new_fragcoord_xy = nir_fadd_imm(b, new_fragcoord_xy, 0.5);
nir_def *fragcoord = nir_load_frag_coord(b);
nir_def *fragcoord = nir_build_frag_coord(b, 4);
nir_def_replace(&intrin->def,
nir_vec4(b, nir_channel(b, new_fragcoord_xy, 0),
nir_channel(b, new_fragcoord_xy, 1),
@ -521,7 +521,7 @@ lower_ps_intrinsic(nir_builder *b, nir_intrinsic_instr *intrin, void *state)
* Instead, compute pixel_coord from frag_coord.
*/
if (s->use_fragcoord) {
nir_def *new_pixel_coord = nir_f2u16(b, nir_channels(b, nir_load_frag_coord(b), 0x3));
nir_def *new_pixel_coord = nir_f2u16(b, nir_build_frag_coord(b, 2));
nir_def_replace(&intrin->def, new_pixel_coord);
return true;
}

2
src/amd/vulkan/nir/radv_meta_nir.c
View file

@ -1330,7 +1330,7 @@ radv_meta_nir_build_resolve_fs(bool use_fmask, int samples, bool is_integer, VkI
nir_variable *fs_out = nir_variable_create(b.shader, nir_var_shader_out, vec4, "f_out");
fs_out->data.location = location;
nir_def *pos_in = nir_trim_vector(&b, nir_load_frag_coord(&b), 2);
nir_def *pos_in = nir_u2f32(&b, nir_load_pixel_coord(&b));
nir_def *src_offset = nir_load_push_constant(&b, 2, 32, nir_imm_int(&b, 0), .range = 8);
nir_def *pos_int = nir_f2i32(&b, pos_in);

2
src/amd/vulkan/nir/radv_nir_lower_fs_intrinsics.c
View file

@ -135,7 +135,7 @@ lower_load_input_attachment(nir_builder *b, nir_intrinsic_instr *intrin, void *s
case nir_intrinsic_load_input_attachment_coord: {
b->cursor = nir_before_instr(&intrin->instr);
nir_def *pos = nir_load_frag_coord(b);
nir_def *pos = nir_u2f32(b, nir_load_pixel_coord(b));
nir_def *layer = nir_load_layer_id(b);
nir_def *coord = nir_vec3(b, nir_f2i32(b, nir_channel(b, pos, 0)), nir_f2i32(b, nir_channel(b, pos, 1)), layer);

2
src/compiler/nir/nir_lower_alpha.c
View file

@ -62,7 +62,7 @@ alpha_to_coverage(nir_builder *b, nir_def *alpha, bool has_intrinsic)
/* Rotate the mask based on (pixel.x % 2) + (pixel.y % 2). This provides
* dithering and randomizes the sample locations.
*/
nir_def *pixel = nir_f2u32(b, nir_channels(b, nir_load_frag_coord(b), 0x3));
nir_def *pixel = nir_f2u32(b, nir_build_frag_coord(b, 2));
nir_def *rotate_amount =
nir_iadd(b, nir_iand_imm(b, nir_channel(b, pixel, 0), 0x1),
nir_iand_imm(b, nir_channel(b, pixel, 1), 0x1));

2
src/compiler/nir/nir_lower_fb_read.c
View file

@ -55,7 +55,7 @@ nir_lower_fb_read_instr(nir_builder *b, nir_intrinsic_instr *intr,
b->cursor = nir_before_instr(&intr->instr);
nir_def *fragcoord = nir_load_frag_coord(b);
nir_def *fragcoord = nir_build_frag_coord(b, 2);
nir_def *sampid = nir_load_sample_id(b);
nir_def *layer = nir_load_layer_id(b);
fragcoord = nir_f2i32(b, fragcoord);

6
src/compiler/nir/nir_lower_input_attachments.c
View file

@ -28,12 +28,14 @@ static nir_def *
load_frag_coord(nir_builder *b, nir_deref_instr *deref,
const nir_input_attachment_options *options)
{
nir_def *frag_coord = nir_load_frag_coord(b);
nir_def *frag_coord = nir_build_frag_coord(b, 2);
if (options->gmem_input_attachment_ir3 ||
options->gmem_depth_stencil_ir3) {
nir_variable *var = nir_deref_instr_get_variable(deref);
unsigned base = var->data.index;
nir_def *gmem_frag_coord = nir_load_frag_coord_gmem_ir3(b);
nir_def *gmem_frag_coord = nir_trim_vector(b, nir_load_frag_coord_gmem_ir3(b), 2);
if (deref->deref_type == nir_deref_type_array &&
options->gmem_input_attachment_ir3) {
nir_def *gmem =

2
src/compiler/nir/nir_lower_printf.c
View file

@ -312,7 +312,7 @@ void nir_printf_fmt_at_px(nir_builder *b, unsigned ptr_bit_size, unsigned x_px,
va_list ap;
nir_def *xy_px = b->shader->options->has_pixel_coord ?
nir_load_pixel_coord(b) : nir_f2u32(b, nir_load_frag_coord(b));
nir_load_pixel_coord(b) : nir_f2u32(b, nir_build_frag_coord(b, 2));
nir_def *is_at_px = b->shader->options->has_pixel_coord ?
nir_ball_iequal(b, nir_imm_uvec2_intN(b, x_px, y_px, 16), xy_px) :
nir_ball_iequal(b, nir_imm_ivec2(b, x_px, y_px), xy_px);

3
src/gallium/auxiliary/nir/nir_draw_helpers.c
View file

@ -65,7 +65,8 @@ nir_lower_pstipple_block(nir_block *block,
b->cursor = nir_before_block(block);
nir_def *frag_coord = state->fs_pos_is_sysval ? nir_load_frag_coord(b) : load_frag_coord(b);
nir_def *frag_coord = state->fs_pos_is_sysval ? nir_build_frag_coord(b, 4)
: load_frag_coord(b);
texcoord = nir_fmul(b, nir_trim_vector(b, frag_coord, 2),
nir_imm_vec2(b, 1.0/32.0, 1.0/32.0));

2
src/gallium/drivers/iris/iris_indirect_gen.c
View file

@ -79,7 +79,7 @@
static nir_def *
load_fragment_index(nir_builder *b)
{
nir_def *pos_in = nir_f2i32(b, nir_trim_vector(b, nir_load_frag_coord(b), 2));
nir_def *pos_in = nir_f2i32(b, nir_build_frag_coord(b, 2));
return nir_iadd(b,
nir_imul_imm(b, nir_channel(b, pos_in, 1), 8192),
nir_channel(b, pos_in, 0));

4
src/gallium/frontends/lavapipe/nir/lvp_nir_lower_input_attachments.c
View file

@ -59,8 +59,8 @@ try_lower_input_load(nir_intrinsic_instr *load, bool use_fragcoord_sysval)
nir_builder b = nir_builder_at(nir_before_instr(&load->instr));
nir_def *frag_coord = use_fragcoord_sysval ? nir_load_frag_coord(&b)
: load_frag_coord(&b);
nir_def *frag_coord = use_fragcoord_sysval ? nir_build_frag_coord(&b, 2)
: load_frag_coord(&b);
frag_coord = nir_f2i32(&b, frag_coord);
nir_def *offset = nir_trim_vector(&b, load->src[1].ssa, 2);
nir_def *pos = nir_iadd(&b, frag_coord, offset);

4
src/intel/blorp/blorp_blit.c
View file

@ -73,7 +73,7 @@ blorp_blit_get_frag_coords(nir_builder *b,
const struct blorp_blit_prog_key *key,
struct blorp_blit_vars *v)
{
nir_def *coord = nir_f2i32(b, nir_load_frag_coord(b));
nir_def *coord = nir_f2i32(b, nir_build_frag_coord(b, 2));
/* Account for destination surface intratile offset
*
@ -91,7 +91,7 @@ blorp_blit_get_frag_coords(nir_builder *b,
return nir_vec3(b, nir_channel(b, coord, 0), nir_channel(b, coord, 1),
nir_load_sample_id(b));
} else {
return nir_trim_vector(b, coord, 2);
return coord;
}
}

6
src/intel/blorp/blorp_clear.c
View file

@ -98,8 +98,8 @@ blorp_params_get_clear_kernel_fs(struct blorp_batch *batch,
nir_def *color = nir_load_var(&b, v_color);
if (clear_rgb_as_red) {
nir_def *pos = nir_f2i32(&b, nir_load_frag_coord(&b));
nir_def *comp = nir_umod_imm(&b, nir_channel(&b, pos, 0), 3);
nir_def *pos = nir_f2i32(&b, nir_build_frag_coord(&b, 1));
nir_def *comp = nir_umod_imm(&b, pos, 3);
color = nir_pad_vec4(&b, nir_vector_extract(&b, color, comp));
}
@ -1530,7 +1530,7 @@ blorp_params_get_mcs_partial_resolve_kernel(struct blorp_batch *batch,
/* Do an MCS fetch and check if it is equal to the magic clear value */
nir_def *mcs =
blorp_nir_txf_ms_mcs(&b, nir_f2i32(&b, nir_load_frag_coord(&b)),
blorp_nir_txf_ms_mcs(&b, nir_f2i32(&b, nir_build_frag_coord(&b, 2)),
nir_load_layer_id(&b),
blorp->isl_dev->info);
nir_def *is_clear =

2
src/intel/vulkan/genX_internal_kernels.c
View file

@ -47,7 +47,7 @@ _load_param(nir_builder *b, unsigned bit_size, unsigned base, unsigned range)
static nir_def *
load_fragment_index(nir_builder *b)
{
nir_def *pos_in = nir_f2i32(b, nir_trim_vector(b, nir_load_frag_coord(b), 2));
nir_def *pos_in = nir_f2i32(b, nir_build_frag_coord(b, 2));
return nir_iadd(b,
nir_imul_imm(b, nir_channel(b, pos_in, 1), 8192),
nir_channel(b, pos_in, 0));

2
src/kosmickrisp/compiler/msl_nir_lower_common.c
View file

@ -205,7 +205,7 @@ msl_ensure_depth_write(nir_shader *nir)
nir_builder b = nir_builder_at(nir_before_impl(entrypoint));
nir_deref_instr *depth_deref = nir_build_deref_var(&b, depth_var);
nir_def *position = nir_load_frag_coord(&b);
nir_def *position = nir_build_frag_coord(&b, 3);
nir_store_deref(&b, depth_deref, nir_channel(&b, position, 2u),
0xFFFFFFFF);

2
src/nouveau/vulkan/nvk_nir_lower_descriptors.c
View file

@ -858,7 +858,7 @@ lower_load_input_attachment_coord(nir_builder *b, nir_intrinsic_instr *load,
{
b->cursor = nir_before_instr(&load->instr);
nir_def *pos = nir_f2i32(b, nir_load_frag_coord(b));
nir_def *pos = nir_f2i32(b, nir_build_frag_coord(b, 2));
nir_def *layer = nir_load_layer_id(b);
nir_def *view = load_root_table(b, 1, 32, draw.view_index, ctx);