This method checks if a source type is identical to or can be implicitly converted to a target type according to the GLSL 1.20 spec, Section 4.1.10 Implicit Conversions.
The following commits use the method for a bugfix: glsl: Fix implicit conversions in non-constructor function calls glsl: Fix implicit conversions in array constructors Note: This is a candidate for the 7.10 and 7.11 branches. CC: Ian Romanick <ian.d.roman...@intel.com> CC: Kenneth Graunke <kenn...@whitecape.org> Signed-off-by: Chad Versace <c...@chad-versace.us> --- src/glsl/glsl_types.cpp | 30 ++++++++++++++++++++++++++++++ src/glsl/glsl_types.h | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 0 deletions(-) diff --git a/src/glsl/glsl_types.cpp b/src/glsl/glsl_types.cpp index a5e21bb..9cfdcab 100644 --- a/src/glsl/glsl_types.cpp +++ b/src/glsl/glsl_types.cpp @@ -523,3 +523,33 @@ glsl_type::component_slots() const return 0; } } + +bool +glsl_type::can_implicitly_convert_to(const glsl_type *desired) const +{ + if (this == desired) + return true; + + /* There is no conversion among matrix types. */ + if (this->matrix_columns != 1 || desired->matrix_columns != 1) + return false; + + switch (desired->base_type) { + case GLSL_TYPE_UINT: + case GLSL_TYPE_INT: + case GLSL_TYPE_BOOL: + case GLSL_TYPE_SAMPLER: + case GLSL_TYPE_STRUCT: + case GLSL_TYPE_VOID: + case GLSL_TYPE_ERROR: + return false; + + case GLSL_TYPE_FLOAT: + return this->is_integer() + && this->vector_elements == desired->vector_elements; + + default: + assert(0); + return false; + } +} diff --git a/src/glsl/glsl_types.h b/src/glsl/glsl_types.h index 87f57e7..6add33e 100644 --- a/src/glsl/glsl_types.h +++ b/src/glsl/glsl_types.h @@ -224,6 +224,46 @@ struct glsl_type { */ unsigned component_slots() const; + /** + * \brief Can this type be implicitly converted to another? + * + * \return True if the types are identical or if this type can be converted + * to \c desired according to Section 4.1.10 of the GLSL spec. + * + * \verbatim + * From page 25 (31 of the pdf) of the GLSL 1.50 spec, Section 4.1.10 + * Implicit Conversions: + * + * In some situations, an expression and its type will be implicitly + * converted to a different type. The following table shows all allowed + * implicit conversions: + * + * Type of expression | Can be implicitly converted to + * -------------------------------------------------- + * int float + * uint + * + * ivec2 vec2 + * uvec2 + * + * ivec3 vec3 + * uvec3 + * + * ivec4 vec4 + * uvec4 + * + * There are no implicit array or structure conversions. For example, + * an array of int cannot be implicitly converted to an array of float. + * There are no implicit conversions between signed and unsigned + * integers. When an implicit conversion is done, it is not a + * re-interpretation of the expression's bit pattern, but a conversion + * of its value to an equivalent value in the new type. For example, + * the integer value -5 will be converted to the floating-point value + * -5.0. Integer values having more bits of precision than a floating + * point mantissa will lose precision when converted to float. + * \endverbatim + */ + bool can_implicitly_convert_to(const glsl_type *desired) const; /** * Query whether or not a type is a scalar (non-vector and non-matrix). -- 1.7.6 _______________________________________________ mesa-dev mailing list mesa-dev@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/mesa-dev