On GLSL that info is set as a layout qualifier when redeclaring
gl_FragCoord, so somehow tied to a specific variable. But in practice,
they behave as a global of the shader. On ARB programs they are set
using a global OPTION (defined at ARB_fragment_coord_conventions), and
on SPIR-V using ExecutionModes, that are also not tied specifically to
the builtin.
This patch moves that info from nir variable and ir variable to nir
shader and gl_program shader_info respectively, so the map is more
similar to SPIR-V, and ARB programs, instead of more similar to GLSL.
FWIW, shader_info.fs already had pixel_center_integer, so this change
also removes some redundancy. Also, as struct gl_program also includes
a shader_info, we removed gl_program::OriginUpperLeft and
PixelCenterInteger, as it would be superfluous.
This change was needed because recently spirv_to_nir changed the order
in which execution modes and variables are handled, so the variables
didn't get the correct values. Now the info is set on the shader
itself, and we don't need to go back to the builtin variable to set
it.
Fixes:
e68871f6a ("spirv: Handle constants and types before execution
modes")
v2: (Jason)
* glsl_to_nir: get the info before glsl_to_nir, while all the rest
of the info gathering is happening
* prog_to_nir: gather the info on a general info-gathering pass,
not on variable setup.
v3: (Jason)
* Squash with the patch that removes that info from ir variable
* anv: assert that OriginUpperLeft is true. It should be already
set by spirv_to_nir.
* blorp: set origin_upper_left on its core "compile fragment
shader", not just on some specific places (for this we added an
helper on a previous patch).
* prog_to_nir: no need to gather specifically this fragcoord modes
as the full gl_program shader_info is copied.
* spirv_to_nir: assert that we are a fragment shader when handling
this execution modes.
v4: (reported by failing gitlab pipeline #18750)
* state_tracker: update too due changes on ir.h/gl_program
v5:
* blorp: minor change after change on previous patch
* radeonsi: update due this change.
v6: (Timothy Arceri)
* prog_to_nir: remove extra whitespace
* shader_info: don't use :1 on origin_upper_left
* glsl: program.fs.origin_upper_left/pixel_center_integer can be
move out of the shader list loop
state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
}
- var->data.pixel_center_integer = qual->flags.q.pixel_center_integer;
- var->data.origin_upper_left = qual->flags.q.origin_upper_left;
if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
&& (strcmp(var->name, "gl_FragCoord") != 0)) {
const char *const qual_string = (qual->flags.q.origin_upper_left)
&& strcmp(var->name, "gl_FragCoord") == 0) {
/* Allow redeclaration of gl_FragCoord for ARB_fcc layout
* qualifiers.
+ *
+ * We don't really need to do anything here, just allow the
+ * redeclaration. Any error on the gl_FragCoord is handled on the ast
+ * level at apply_layout_qualifier_to_variable using the
+ * ast_type_qualifier and _mesa_glsl_parse_state, or later at
+ * linker.cpp.
*/
- earlier->data.origin_upper_left = var->data.origin_upper_left;
- earlier->data.pixel_center_integer = var->data.pixel_center_integer;
-
/* According to section 4.3.7 of the GLSL 1.30 spec,
* the following built-in varaibles can be redeclared with an
* interpolation qualifier:
shader->info.has_transform_feedback_varyings |=
shader_prog->last_vert_prog->sh.LinkedTransformFeedback->NumVarying > 0;
+ if (shader->info.stage == MESA_SHADER_FRAGMENT) {
+ shader->info.fs.pixel_center_integer = sh->Program->info.fs.pixel_center_integer;
+ shader->info.fs.origin_upper_left = sh->Program->info.fs.origin_upper_left;
+ }
+
return shader;
}
}
var->data.interpolation = ir->data.interpolation;
- var->data.origin_upper_left = ir->data.origin_upper_left;
- var->data.pixel_center_integer = ir->data.pixel_center_integer;
var->data.location_frac = ir->data.location_frac;
switch (ir->data.depth_layout) {
this->data.warn_extension_index = 0;
this->constant_value = NULL;
this->constant_initializer = NULL;
- this->data.origin_upper_left = false;
- this->data.pixel_center_integer = false;
this->data.depth_layout = ir_depth_layout_none;
this->data.used = false;
this->data.always_active_io = false;
unsigned interpolation:2;
/**
- * \name ARB_fragment_coord_conventions
- * @{
- */
- unsigned origin_upper_left:1;
- unsigned pixel_center_integer:1;
- /*@}*/
-
- /**
* Was the location explicitly set in the shader?
*
* If the location is explicitly set in the shader, it \b cannot be changed
shader->SampleInterlockOrdered;
linked_shader->Program->info.fs.sample_interlock_unordered |=
shader->SampleInterlockUnordered;
-
linked_shader->Program->sh.fs.BlendSupport |= shader->BlendSupport;
}
+
+ linked_shader->Program->info.fs.pixel_center_integer = pixel_center_integer;
+ linked_shader->Program->info.fs.origin_upper_left = origin_upper_left;
}
/**
unsigned interpolation:2;
/**
- * \name ARB_fragment_coord_conventions
- * @{
- */
- unsigned origin_upper_left:1;
- unsigned pixel_center_integer:1;
- /*@}*/
-
- /**
* If non-zero, then this variable may be packed along with other variables
* into a single varying slot, so this offset should be applied when
* accessing components. For example, an offset of 1 means that the x
break;
}
- case SYSTEM_VALUE_FRAG_COORD:
- assert(b->shader->info.stage == MESA_SHADER_FRAGMENT);
- b->shader->info.fs.pixel_center_integer =
- var->data.pixel_center_integer;
- break;
-
default:
break;
}
* u,h -> l,i: (99.5 + 0.5) * -1 + 100 = 0
*/
- if (fragcoord->data.origin_upper_left) {
+ if (state->shader->info.fs.origin_upper_left) {
/* Fragment shader wants origin in upper-left */
if (options->fs_coord_origin_upper_left) {
/* the driver supports upper-left origin */
}
}
- if (fragcoord->data.pixel_center_integer) {
+ if (state->shader->info.fs.pixel_center_integer) {
/* Fragment shader wants pixel center integer */
if (options->fs_coord_pixel_center_integer) {
/* the driver supports pixel center integer */
bool post_depth_coverage;
+ /**
+ * \name ARB_fragment_coord_conventions
+ * @{
+ */
bool pixel_center_integer;
+ bool origin_upper_left;
+ /*@}*/
bool pixel_interlock_ordered;
bool pixel_interlock_unordered;
switch(mode->exec_mode) {
case SpvExecutionModeOriginUpperLeft:
case SpvExecutionModeOriginLowerLeft:
- b->origin_upper_left =
+ vtn_assert(b->shader->info.stage == MESA_SHADER_FRAGMENT);
+ b->shader->info.fs.origin_upper_left =
(mode->exec_mode == SpvExecutionModeOriginUpperLeft);
break;
break;
case SpvExecutionModePixelCenterInteger:
- b->pixel_center_integer = true;
+ vtn_assert(b->shader->info.stage == MESA_SHADER_FRAGMENT);
+ b->shader->info.fs.pixel_center_integer = true;
break;
case SpvExecutionModeXfb:
const char *entry_point_name;
struct vtn_value *entry_point;
struct vtn_value *workgroup_size_builtin;
- bool origin_upper_left;
- bool pixel_center_integer;
bool variable_pointers;
struct vtn_function *func;
case SpvBuiltInCullDistance:
var_data->compact = true;
break;
- case SpvBuiltInFragCoord:
- var_data->pixel_center_integer = b->pixel_center_integer;
- /* fallthrough */
- case SpvBuiltInSamplePosition:
- var_data->origin_upper_left = b->origin_upper_left;
- break;
default:
break;
}
/* Fragment shader position is a system value. */
if (nir->info.stage == MESA_SHADER_FRAGMENT &&
variable->data.location == VARYING_SLOT_POS) {
- if (variable->data.pixel_center_integer)
+ if (nir->info.fs.pixel_center_integer)
info->properties[TGSI_PROPERTY_FS_COORD_PIXEL_CENTER] =
TGSI_FS_COORD_PIXEL_CENTER_INTEGER;
v->frag_coord = nir_variable_create(b->shader, nir_var_shader_in,
glsl_vec4_type(), "gl_FragCoord");
v->frag_coord->data.location = VARYING_SLOT_POS;
- v->frag_coord->data.origin_upper_left = true;
v->color_out = nir_variable_create(b->shader, nir_var_shader_out,
glsl_vec4_type(), "gl_FragColor");
nir_variable_create(b.shader, nir_var_shader_in,
glsl_vec4_type(), "gl_FragCoord");
frag_coord->data.location = VARYING_SLOT_POS;
- frag_coord->data.origin_upper_left = true;
nir_ssa_def *pos = nir_f2i32(&b, nir_load_var(&b, frag_coord));
nir_ssa_def *comp = nir_umod(&b, nir_channel(&b, pos, 0),
nir_builder_init_simple_shader(b, mem_ctx, stage, NULL);
if (name != NULL)
b->shader->info.name = ralloc_strdup(b->shader, name);
+ if (stage == MESA_SHADER_FRAGMENT)
+ b->shader->info.fs.origin_upper_left = true;
}
static inline nir_ssa_def *
glsl_vec4_type(), "gl_FragCoord");
frag_coord->data.location = VARYING_SLOT_POS;
- frag_coord->data.origin_upper_left = true;
return nir_load_var(b, frag_coord);
}
nir_variable *pos = nir_variable_create(b->shader, nir_var_shader_in,
glsl_vec4_type(), NULL);
pos->data.location = VARYING_SLOT_POS;
- pos->data.origin_upper_left = true;
+ /**
+ * From Vulkan spec:
+ * "The OriginLowerLeft execution mode must not be used; fragment entry
+ * points must declare OriginUpperLeft."
+ *
+ * So at this point origin_upper_left should be true
+ */
+ assert(b->shader->info.fs.origin_upper_left == true);
return nir_load_var(b, pos);
}
/** Texture units used for samplerExternalOES */
GLbitfield ExternalSamplersUsed;
- /* Fragement shader only fields */
- GLboolean OriginUpperLeft;
- GLboolean PixelCenterInteger;
-
/** Named parameters, constants, etc. from program text */
struct gl_program_parameter_list *Parameters;
program->SamplersUsed |= (1 << i);
}
program->ShadowSamplers = prog.ShadowSamplers;
- program->OriginUpperLeft = state.option.OriginUpperLeft;
- program->PixelCenterInteger = state.option.PixelCenterInteger;
+ program->info.fs.origin_upper_left = state.option.OriginUpperLeft;
+ program->info.fs.pixel_center_integer = state.option.PixelCenterInteger;
program->info.fs.uses_discard = state.fragment.UsesKill;
void
ir_to_mesa_visitor::visit(ir_variable *ir)
{
- if (strcmp(ir->name, "gl_FragCoord") == 0) {
- this->prog->OriginUpperLeft = ir->data.origin_upper_left;
- this->prog->PixelCenterInteger = ir->data.pixel_center_integer;
- }
-
if (ir->data.mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) {
unsigned int i;
const ir_state_slot *const slots = ir->get_state_slots();
var->data.index = 0;
if (c->prog->Target == GL_FRAGMENT_PROGRAM_ARB) {
- if (i == VARYING_SLOT_POS) {
- var->data.origin_upper_left = c->prog->OriginUpperLeft;
- var->data.pixel_center_integer = c->prog->PixelCenterInteger;
- } else if (i == VARYING_SLOT_FOGC) {
+ if (i == VARYING_SLOT_FOGC) {
/* fogcoord is defined as <f, 0.0, 0.0, 1.0>. Make the actual
* input variable a float, and create a local containing the
* full vec4 value.
var->data.location = i;
var->data.index = 0;
- if (c->prog->Target == GL_FRAGMENT_PROGRAM_ARB &&
- i == SYSTEM_VALUE_FRAG_COORD) {
- var->data.origin_upper_left = c->prog->OriginUpperLeft;
- var->data.pixel_center_integer = c->prog->PixelCenterInteger;
- }
-
c->sysval_vars[i] = var;
}
void
glsl_to_tgsi_visitor::visit(ir_variable *ir)
{
- if (strcmp(ir->name, "gl_FragCoord") == 0) {
- this->prog->OriginUpperLeft = ir->data.origin_upper_left;
- this->prog->PixelCenterInteger = ir->data.pixel_center_integer;
- }
-
if (ir->data.mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) {
unsigned int i;
const ir_state_slot *const slots = ir->get_state_slots();
* u,i -> l,h: (99.0 + 0.5) * -1 + 100 = 0.5
* u,h -> l,i: (99.5 + 0.5) * -1 + 100 = 0
*/
- if (program->OriginUpperLeft) {
+ if (program->info.fs.origin_upper_left) {
/* Fragment shader wants origin in upper-left */
if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {
/* the driver supports upper-left origin */
assert(0);
}
- if (program->PixelCenterInteger) {
+ if (program->info.fs.pixel_center_integer) {
/* Fragment shader wants pixel center integer */
if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
/* the driver supports pixel center integer */
* u,i -> l,h: (99.0 + 0.5) * -1 + 100 = 0.5
* u,h -> l,i: (99.5 + 0.5) * -1 + 100 = 0
*/
- if (program->OriginUpperLeft) {
+ if (program->info.fs.origin_upper_left) {
/* Fragment shader wants origin in upper-left */
if (pscreen->get_param(pscreen,
PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {
assert(0);
}
- if (program->PixelCenterInteger) {
+ if (program->info.fs.pixel_center_integer) {
/* Fragment shader wants pixel center integer */
if (pscreen->get_param(pscreen,
PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
GLfloat *wpos = span->array->attribs[VARYING_SLOT_POS][col];
/* ARB_fragment_coord_conventions */
- if (program->OriginUpperLeft)
+ if (program->info.fs.origin_upper_left)
wpos[1] = ctx->DrawBuffer->Height - 1 - wpos[1];
- if (!program->PixelCenterInteger) {
+ if (!program->info.fs.pixel_center_integer) {
wpos[0] += 0.5F;
wpos[1] += 0.5F;
}