* Evaluate the given exec_node (which should be an ast_node representing
* a single array dimension) and return its integer value.
*/
-static const unsigned
+static unsigned
process_array_size(exec_node *node,
struct _mesa_glsl_parse_state *state)
{
{
bool fail = false;
- /* In the vertex shader only shader inputs can be given explicit
- * locations.
+ /* Between GL_ARB_explicit_attrib_location an
+ * GL_ARB_separate_shader_objects, the inputs and outputs of any shader
+ * stage can be assigned explicit locations. The checking here associates
+ * the correct extension with the correct stage's input / output:
*
- * In the fragment shader only shader outputs can be given explicit
- * locations.
+ * input output
+ * ----- ------
+ * vertex explicit_loc sso
+ * geometry sso sso
+ * fragment sso explicit_loc
*/
switch (state->stage) {
case MESA_SHADER_VERTEX:
break;
}
+ if (var->data.mode == ir_var_shader_out) {
+ if (!state->check_separate_shader_objects_allowed(loc, var))
+ return;
+
+ break;
+ }
+
fail = true;
break;
case MESA_SHADER_GEOMETRY:
- _mesa_glsl_error(loc, state,
- "geometry shader variables cannot be given "
- "explicit locations");
- return;
+ if (var->data.mode == ir_var_shader_in || var->data.mode == ir_var_shader_out) {
+ if (!state->check_separate_shader_objects_allowed(loc, var))
+ return;
+
+ break;
+ }
+
+ fail = true;
+ break;
case MESA_SHADER_FRAGMENT:
+ if (var->data.mode == ir_var_shader_in) {
+ if (!state->check_separate_shader_objects_allowed(loc, var))
+ return;
+
+ break;
+ }
+
if (var->data.mode == ir_var_shader_out) {
if (!state->check_explicit_attrib_location_allowed(loc, var))
return;
* ensures that negative values stay negative.
*/
if (qual->location >= 0) {
- var->data.location = (state->stage == MESA_SHADER_VERTEX)
- ? (qual->location + VERT_ATTRIB_GENERIC0)
- : (qual->location + FRAG_RESULT_DATA0);
+ switch (state->stage) {
+ case MESA_SHADER_VERTEX:
+ var->data.location = (var->data.mode == ir_var_shader_in)
+ ? (qual->location + VERT_ATTRIB_GENERIC0)
+ : (qual->location + VARYING_SLOT_VAR0);
+ break;
+
+ case MESA_SHADER_GEOMETRY:
+ var->data.location = qual->location + VARYING_SLOT_VAR0;
+ break;
+
+ case MESA_SHADER_FRAGMENT:
+ var->data.location = (var->data.mode == ir_var_shader_out)
+ ? (qual->location + FRAG_RESULT_DATA0)
+ : (qual->location + VARYING_SLOT_VAR0);
+ break;
+ case MESA_SHADER_COMPUTE:
+ assert(!"Unexpected shader type");
+ break;
+ }
} else {
var->data.location = qual->location;
}
}
}
}
-
- return;
}
static void
var->data.image.write_only |= qual->flags.q.write_only;
var->data.image.coherent |= qual->flags.q.coherent;
var->data.image._volatile |= qual->flags.q._volatile;
- var->data.image._restrict |= qual->flags.q._restrict;
+ var->data.image.restrict_flag |= qual->flags.q.restrict_flag;
var->data.read_only = true;
if (qual->flags.q.explicit_image_format) {
"cannot initialize uniforms");
}
- if (var->type->is_sampler()) {
+ /* From section 4.1.7 of the GLSL 4.40 spec:
+ *
+ * "Opaque variables [...] are initialized only through the
+ * OpenGL API; they cannot be declared with an initializer in a
+ * shader."
+ */
+ if (var->type->contains_opaque()) {
_mesa_glsl_error(& initializer_loc, state,
- "cannot initialize samplers");
+ "cannot initialize opaque variable");
}
if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL)) {
{
unsigned num_vertices = 0;
if (state->gs_input_prim_type_specified) {
- num_vertices = vertices_per_prim(state->gs_input_prim_type);
+ num_vertices = vertices_per_prim(state->in_qualifier->prim_type);
}
/* Geometry shader input variables must be arrays. Caller should have
* "In addition, all identifiers containing two
* consecutive underscores (__) are reserved as
* possible future keywords."
+ *
+ * The intention is that names containing __ are reserved for internal
+ * use by the implementation, and names prefixed with GL_ are reserved
+ * for use by Khronos. Names simply containing __ are dangerous to use,
+ * but should be allowed.
+ *
+ * A future version of the GLSL specification will clarify this.
*/
- _mesa_glsl_error(&loc, state,
- "identifier `%s' uses reserved `__' string",
- identifier);
+ _mesa_glsl_warning(&loc, state,
+ "identifier `%s' uses reserved `__' string",
+ identifier);
}
}
*/
if (!state->is_version(130, 300)
&& !state->has_explicit_attrib_location()
+ && !state->has_separate_shader_objects()
&& !state->ARB_fragment_coord_conventions_enable) {
if (this->type->qualifier.flags.q.out) {
_mesa_glsl_error(& loc, state,
", integer and sampler types");
}
- /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
+ /* From section 4.1.7 of the GLSL 4.40 spec:
*
- * "[Sampler types] can only be declared as function
- * parameters or uniform variables (see Section 4.3.5
- * "Uniform")".
+ * "[Opaque types] can only be declared as function
+ * parameters or uniform-qualified variables."
*/
- if (var_type->contains_sampler() &&
+ if (var_type->contains_opaque() &&
!this->type->qualifier.flags.q.uniform) {
- _mesa_glsl_error(&loc, state, "samplers must be declared uniform");
+ _mesa_glsl_error(&loc, state,
+ "opaque variables must be declared uniform");
}
/* Process the initializer and add its instructions to a temporary
apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc,
true);
- /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
+ /* From section 4.1.7 of the GLSL 4.40 spec:
*
- * "Samplers cannot be treated as l-values; hence cannot be used
- * as out or inout function parameters, nor can they be assigned
- * into."
+ * "Opaque variables cannot be treated as l-values; hence cannot
+ * be used as out or inout function parameters, nor can they be
+ * assigned into."
*/
if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out)
- && type->contains_sampler()) {
- _mesa_glsl_error(&loc, state, "out and inout parameters cannot contain samplers");
+ && type->contains_opaque()) {
+ _mesa_glsl_error(&loc, state, "out and inout parameters cannot "
+ "contain opaque variables");
type = glsl_type::error_type;
}
"sized", name);
}
- /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
+ /* From section 4.1.7 of the GLSL 4.40 spec:
*
- * "[Sampler types] can only be declared as function parameters
- * or uniform variables (see Section 4.3.5 "Uniform")".
+ * "[Opaque types] can only be declared as function parameters
+ * or uniform-qualified variables."
*/
- if (return_type->contains_sampler()) {
+ if (return_type->contains_opaque()) {
YYLTYPE loc = this->get_location();
_mesa_glsl_error(&loc, state,
- "function `%s' return type can't contain a sampler",
+ "function `%s' return type can't contain an opaque type",
name);
}
if (!allow_reserved_names)
validate_identifier(decl->identifier, loc, state);
- /* From the GL_ARB_uniform_buffer_object spec:
+ /* From section 4.3.9 of the GLSL 4.40 spec:
*
- * "Sampler types are not allowed inside of uniform
- * blocks. All other types, arrays, and structures
- * allowed for uniforms are allowed within a uniform
- * block."
+ * "[In interface blocks] opaque types are not allowed."
*
* It should be impossible for decl_type to be NULL here. Cases that
* might naturally lead to decl_type being NULL, especially for the
const struct glsl_type *field_type =
decl_type != NULL ? decl_type : glsl_type::error_type;
- if (is_interface && field_type->contains_sampler()) {
+ if (is_interface && field_type->contains_opaque()) {
YYLTYPE loc = decl_list->get_location();
_mesa_glsl_error(&loc, state,
- "uniform in non-default uniform block contains sampler");
+ "uniform in non-default uniform block contains "
+ "opaque variable");
}
if (field_type->contains_atomic()) {
* was consistent with this one.
*/
if (state->gs_input_prim_type_specified &&
- state->gs_input_prim_type != this->prim_type) {
+ state->in_qualifier->prim_type != this->prim_type) {
_mesa_glsl_error(&loc, state,
"geometry shader input layout does not match"
" previous declaration");
}
state->gs_input_prim_type_specified = true;
- state->gs_input_prim_type = this->prim_type;
/* If any shader inputs occurred before this declaration and did not
* specify an array size, their size is determined now.
projects / mesa.git / blobdiff