This allows to set data of u/byte, u/short and half types for attributes with the shader runner.
For example: attname0/byte/int attname1/ushort/uint attname3/half/float The syntax has been extended so the recommended way has replaced the old COUNT field in the [vertex data] header line with the corresponding GLSL type for the old TYPE field. In any case, the extended syntax is backward compatible so it is still possible to specify a vec3 attribute like: attname/float/3 In addition to the now recommended format: attname/float/vec3 Due to this, the arb_vertex_attrib_64bit input tests generator has been also adapted to the new syntax. Signed-off-by: Andres Gomez <[email protected]> --- generated_tests/gen_vs_in_fp64.py | 266 +++++++++++++--- .../gen_vs_in_fp64/columns.shader_test.mako | 20 +- .../gen_vs_in_fp64/regular.shader_test.mako | 31 +- tests/util/piglit-dispatch.h | 1 + tests/util/piglit-vbo.cpp | 340 +++++++++++++++------ 5 files changed, 489 insertions(+), 169 deletions(-) diff --git a/generated_tests/gen_vs_in_fp64.py b/generated_tests/gen_vs_in_fp64.py index fcc87f5..879f0f6 100644 --- a/generated_tests/gen_vs_in_fp64.py +++ b/generated_tests/gen_vs_in_fp64.py @@ -71,47 +71,165 @@ DOUBLE_NORMAL_VALUES = ['0xffefffffffffffff', # Negative maximum normalized '0x4b1e35ed24eb6496', # +7.23401345e+53 '0x7fefffffffffffff'] # Positive maximum normalized -DSCALAR_TYPES = ['double'] - -DVEC_TYPES = ['dvec2', 'dvec3', 'dvec4'] - -DMAT_TYPES = ['dmat2', 'dmat2x3', 'dmat2x4', +FLOAT_POS_ZERO = ['0x00000000'] # 0.0 + +FLOAT_NORMAL_VALUES = ['0xc21620c5', # -3.7532 + '0x75bc289b', # 4.7703e32 + '0x54c1c081', # 6.6572e12 + '0x878218f8', # -1.9575e-34 + '0x7e0857ed', # 4.5307886e37 + '0x2bb561bf', # 1.2887954e-12 + '0xff7fffff', # Negative maximum normalized + '0xcb800000', # -16777216.0 + '0xc0a00000', # -5.0 + '0xbff92e73', # -1.9467300 + '0x80800000', # Negative minimum normalized + '0x00800000', # Positive minimum normalized + '0x3ff92e73', # 1.9467300 + '0x40a00000', # 5.0 + '0x4b800000', # 16777216.0 + '0x7f7fffff'] # Positive maximum normalized + +UBYTE_VALUES = ['0', # Minimum + '127', # Signed byte low frontier + '128', # Signed byte up frontier + '255', # Maximum + '1', + '5', + '14', + '23', + '58', + '91', + '113', + '135', + '179', + '185', + '205', + '207', + '212'] + +BYTE_VALUES = ['-128', # Minimum + '-5', + '-1', + '0', + '1', + '5', + '127', # Maximum + '-125', + '-120', + '-117', + '-69', + '-24', + '-20', + '21', + '89', + '106', + '119'] + +USHORT_VALUES = ['0', # Minimum + '32767', # Signed short low frontier + '32768', # Signed short up frontier + '65535', # Maximum + '1', + '5', + '12610', + '17110', + '19962', + '23589', + '37265', + '41792', + '45699', + '47934', + '55916', + '56412', + '65142'] + +SHORT_VALUES = ['-32768', # Minimum + '-5', + '-1', + '0', + '1', + '5', + '32767', # Maximum + '-16255', + '-12480', + '-12360', + '1706', + '5386', + '7315', + '18137', + '25871', + '26255', + '26472'] + +UINT_VALUES = ['0', # Minimum + '2147483647', # Signed int low frontier + '2147483648', # Signed int up frontier + '4294967295', # Maximum + '1', + '5', + '1073294963', + '1084227584', + '1266679808', + '1421983873', + '2114476013', + '2273450232', + '3220778611', + '3231711232', + '3256230085', + '3414163456', + '4294967294'] + +INT_VALUES = ['-2147483648', # Minimum + '-5', + '-1', + '0', + '1', + '5', + '2147483647', # Maximum + '-1038737211', + '-1063256064', + '-1074188685', + '-880803840', + '1073294963', + '1084227584', + '1266679808', + '1421983873', + '1975265435', + '2114476013'] + +GL_TYPES_VALUES = {'double': DOUBLE_NORMAL_VALUES + DOUBLE_POS_ZERO, + 'float': FLOAT_NORMAL_VALUES + FLOAT_POS_ZERO, + 'ubyte': UBYTE_VALUES, + 'byte': BYTE_VALUES, + 'ushort': USHORT_VALUES, + 'short': SHORT_VALUES, + 'uint': UINT_VALUES, + 'int': INT_VALUES} + +GLSL_DSCALAR_TYPES = ['double'] + +GLSL_DVEC_TYPES = ['dvec2', 'dvec3', 'dvec4'] + +GLSL_DMAT_TYPES = ['dmat2', 'dmat2x3', 'dmat2x4', 'dmat3x2', 'dmat3', 'dmat3x4', 'dmat4x2', 'dmat4x3', 'dmat4'] -FSCALAR_TYPES = ['float'] +GLSL_FSCALAR_TYPES = ['float'] -FVEC_TYPES = ['vec2', 'vec3', 'vec4'] +GLSL_FVEC_TYPES = ['vec2', 'vec3', 'vec4'] -FMAT_TYPES = ['mat2', 'mat2x3', 'mat2x4', +GLSL_FMAT_TYPES = ['mat2', 'mat2x3', 'mat2x4', 'mat3x2', 'mat3', 'mat3x4', 'mat4x2', 'mat4x3', 'mat4'] -ISCALAR_TYPES = ['int'] - -IVEC_TYPES = ['ivec2', 'ivec3', 'ivec4'] +GLSL_ISCALAR_TYPES = ['int'] -USCALAR_TYPES = ['uint'] +GLSL_IVEC_TYPES = ['ivec2', 'ivec3', 'ivec4'] -UVEC_TYPES = ['uvec2', 'uvec3', 'uvec4'] +GLSL_USCALAR_TYPES = ['uint'] -HEX_VALUES_32BIT = ['0xc21620c5', # -3.7532 float, -1038737211 int, 3256230085 uint - '0x75bc289b', # 4.7703e32 float, 1975265435 int, 1975265435 uint - '0x54c1c081', # 6.6572e12 float, 1421983873 int, 1421983873 uint - '0x878218f8', # -1.9575e-34 float, -1038737211 int, 2273450232 uint - '0x7e0857ed', # 4.5307886e+37 float, 2114476013 int, 2114476013 uint - '0x2bb561bf', # 1.2887954e-12 float, 733307327 int, 733307327 uint - '0xff7fffff', # -3.4028235e+38 float, -8388609 int, 4286578687 uint - '0xcb800000', # -16777216.0 float, -880803840 int, 3414163456 uint - '0xc0a00000', # -5.0 float, -1063256064 int, 3231711232 uint - '0xbff92e73', # -1.9467300 float, -1074188685 int, 3220778611 uint - '0x80800000', # -1.1754944e-38 float, -2139095040 int, 2155872256 uint - '0x00000000', # 0.0 float, 0 int, 0 uint - '0x00800000', # 1.1754944e-38 float, 8388608 int, 8388608 uint - '0x3ff92e73', # 1.9467300 float, 1073294963 int, 1073294963 uint - '0x40a00000', # 5.0 float, 1084227584 int, 1084227584 uint - '0x4b800000', # 16777216.0 float, 1266679808 int, 1266679808 uint - '0x7f7fffff'] # 3.4028235e+38 float, 2139095039 int, 2139095039 uint +GLSL_UVEC_TYPES = ['uvec2', 'uvec3', 'uvec4'] # pylint: enable=bad-whitespace,line-too-long @@ -174,15 +292,18 @@ class RegularTestTuple(TestTuple): @staticmethod def create_in_types_array(*types_arrays): """Creates vertex input combinations.""" + for product_item in itertools.product(*types_arrays): yield product_item @staticmethod - def create_tests(glsl_vers, in_types_array, position_orders, arrays_array, names_only): + def create_tests(glsl_vers, in_types_array, gl_types, + position_orders, arrays_array, names_only): """Creates combinations for flat qualifier tests.""" assert isinstance(glsl_vers, list) assert isinstance(in_types_array, types.GeneratorType) + assert isinstance(gl_types, list) assert isinstance(position_orders, list) assert isinstance(arrays_array, list) assert isinstance(names_only, bool) @@ -210,7 +331,7 @@ class RegularTestTuple(TestTuple): if num_vs_in > MAX_VERTEX_ATTRIBS: continue - yield ver, in_types, position_order, arrays, num_vs_in, names_only + yield ver, in_types, gl_types, position_order, arrays, num_vs_in, names_only @staticmethod def all_tests(names_only): @@ -224,10 +345,29 @@ class RegularTestTuple(TestTuple): for test_args in RegularTestTuple.create_tests( ['GL_ARB_vertex_attrib_64bit', '410'], RegularTestTuple.create_in_types_array( - itertools.chain(DSCALAR_TYPES, DVEC_TYPES, DMAT_TYPES), - itertools.chain(FSCALAR_TYPES, FVEC_TYPES, FMAT_TYPES, - ISCALAR_TYPES, IVEC_TYPES, - USCALAR_TYPES, UVEC_TYPES)), + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES), + itertools.chain(GLSL_FSCALAR_TYPES, GLSL_FVEC_TYPES, GLSL_FMAT_TYPES)), + ['double', 'float'], + [1, 2, 3], + [[1, 1], [1, 3], [5, 1], [5, 3]], + names_only): + yield RegularTestTuple(*test_args) + for test_args in RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES), + itertools.chain(GLSL_ISCALAR_TYPES, GLSL_IVEC_TYPES)), + ['double', 'int'], + [1, 2, 3], + [[1, 1], [1, 3], [5, 1], [5, 3]], + names_only): + yield RegularTestTuple(*test_args) + for test_args in RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES), + itertools.chain(GLSL_USCALAR_TYPES, GLSL_UVEC_TYPES)), + ['double', 'uint'], [1, 2, 3], [[1, 1], [1, 3], [5, 1], [5, 3]], names_only): @@ -235,10 +375,9 @@ class RegularTestTuple(TestTuple): for test_args in RegularTestTuple.create_tests( ['GL_ARB_vertex_attrib_64bit', '410'], RegularTestTuple.create_in_types_array( - itertools.chain(FSCALAR_TYPES, FVEC_TYPES, FMAT_TYPES, - ISCALAR_TYPES, IVEC_TYPES, - USCALAR_TYPES, UVEC_TYPES), - itertools.chain(DSCALAR_TYPES, DVEC_TYPES, DMAT_TYPES)), + itertools.chain(GLSL_FSCALAR_TYPES, GLSL_FVEC_TYPES, GLSL_FMAT_TYPES), + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES)), + ['float', 'double'], [1, 2, 3], [[1, 1], [1, 2], [3, 1], [3, 2]], names_only): @@ -246,8 +385,9 @@ class RegularTestTuple(TestTuple): for test_args in RegularTestTuple.create_tests( ['GL_ARB_vertex_attrib_64bit', '410'], RegularTestTuple.create_in_types_array( - itertools.chain(DSCALAR_TYPES, DVEC_TYPES, DMAT_TYPES), - itertools.chain(DSCALAR_TYPES, DVEC_TYPES, DMAT_TYPES)), + itertools.chain(GLSL_ISCALAR_TYPES, GLSL_IVEC_TYPES), + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES)), + ['int', 'double'], [1, 2, 3], [[1, 1], [1, 2], [3, 1], [3, 2]], names_only): @@ -255,15 +395,38 @@ class RegularTestTuple(TestTuple): for test_args in RegularTestTuple.create_tests( ['GL_ARB_vertex_attrib_64bit', '410'], RegularTestTuple.create_in_types_array( - itertools.chain(DSCALAR_TYPES, DVEC_TYPES, DMAT_TYPES)), + itertools.chain(GLSL_USCALAR_TYPES, GLSL_UVEC_TYPES), + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES)), + ['uint', 'double'], + [1, 2, 3], + [[1, 1], [1, 2], [3, 1], [3, 2]], + names_only): + yield RegularTestTuple(*test_args) + for test_args in RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES), + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES)), + ['double', 'double'], + [1, 2, 3], + [[1, 1], [1, 2], [3, 1], [3, 2]], + names_only): + yield RegularTestTuple(*test_args) + for test_args in RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + itertools.chain(GLSL_DSCALAR_TYPES, GLSL_DVEC_TYPES, GLSL_DMAT_TYPES)), + ['double'], [1, 2], [[1], [5]], names_only): yield RegularTestTuple(*test_args) - def __init__(self, ver, in_types, position_order, arrays, num_vs_in, names_only): + def __init__(self, ver, in_types, gl_types, position_order, arrays, num_vs_in, names_only): assert ver in ('GL_ARB_vertex_attrib_64bit', '410', '420') assert isinstance(in_types, tuple) + assert isinstance(gl_types, list) + assert len(gl_types) == len(in_types) assert isinstance(position_order, int) assert (position_order > 0) and (position_order - 1 <= len(in_types)) assert isinstance(arrays, list) @@ -271,6 +434,7 @@ class RegularTestTuple(TestTuple): super(RegularTestTuple, self).__init__(ver, names_only) self._in_types = in_types + self._gl_types = gl_types self._position_order = position_order self._arrays = arrays self._num_vs_in = num_vs_in @@ -282,8 +446,8 @@ class RegularTestTuple(TestTuple): for idx, in_type in enumerate(self._in_types): if idx == self._position_order - 1: filename += '-position' - filename += '-{}{}'.format( - in_type, '-array{}'.format( + filename += '-{}_{}{}'.format( + self._gl_types[idx], in_type, '_array{}'.format( self._arrays[idx]) if self._arrays[idx] - 1 else '') if self._position_order > len(self._in_types): filename += '-position' @@ -295,11 +459,12 @@ class RegularTestTuple(TestTuple): 'regular.shader_test.mako').render_unicode( ver=self._ver, in_types=self._in_types, + gl_types=self._gl_types, position_order=self._position_order, arrays=self._arrays, num_vs_in=self._num_vs_in, - dvalues=DOUBLE_NORMAL_VALUES + DOUBLE_POS_ZERO, - hvalues=HEX_VALUES_32BIT)) + gl_types_values=GL_TYPES_VALUES)) + print(filename) @@ -319,7 +484,7 @@ class ColumnsTestTuple(TestTuple): for ver in glsl_vers: utils.safe_makedirs(TestTuple.get_dir_name(ver)) - for mat in DMAT_TYPES: + for mat in GLSL_DMAT_TYPES: for columns in itertools.product(range(2), repeat=TestTuple.cols(mat)): if (0 not in columns) or (1 not in columns): continue @@ -350,7 +515,8 @@ class ColumnsTestTuple(TestTuple): ver=self._ver, mat=self._mat, columns=self._columns, - dvalues=DOUBLE_NORMAL_VALUES + DOUBLE_POS_ZERO)) + dvalues=GL_TYPES_VALUES['double'])) + print(filename) diff --git a/generated_tests/templates/gen_vs_in_fp64/columns.shader_test.mako b/generated_tests/templates/gen_vs_in_fp64/columns.shader_test.mako index 0da2678..6b159d6 100644 --- a/generated_tests/templates/gen_vs_in_fp64/columns.shader_test.mako +++ b/generated_tests/templates/gen_vs_in_fp64/columns.shader_test.mako @@ -33,19 +33,19 @@ return (glsl_version, glsl_version_int) - def cols(in_type): - if 'mat' in in_type: - if 'x' in in_type: - return int(in_type[-3:][:1]) + def cols(glsl_type): + if 'mat' in glsl_type: + if 'x' in glsl_type: + return int(glsl_type[-3:][:1]) else: - return int(in_type[-1:]) + return int(glsl_type[-1:]) else: return 1 - def rows(in_type): - if 'vec' in in_type or 'mat' in in_type: - return int(in_type[-1:]) + def rows(glsl_type): + if 'vec' in glsl_type or 'mat' in glsl_type: + return int(glsl_type[-1:]) else: return 1 @@ -102,9 +102,9 @@ void main() } [vertex data] -piglit_vertex/vec3/3\ +piglit_vertex/float/vec3\ % for i in range(cols(mat)): - value/${mat}/${rows(mat)}${'/{}'.format(i) if cols(mat) > 1 else ''}\ + value/double/${mat}${'/{}'.format(i) if cols(mat) > 1 else ''}\ % endfor % for d in range(len(dvalues)): diff --git a/generated_tests/templates/gen_vs_in_fp64/regular.shader_test.mako b/generated_tests/templates/gen_vs_in_fp64/regular.shader_test.mako index b727b5e..9d85a6f 100644 --- a/generated_tests/templates/gen_vs_in_fp64/regular.shader_test.mako +++ b/generated_tests/templates/gen_vs_in_fp64/regular.shader_test.mako @@ -33,19 +33,19 @@ return (glsl_version, glsl_version_int) - def cols(in_type): - if 'mat' in in_type: - if 'x' in in_type: - return int(in_type[-3:][:1]) + def cols(glsl_type): + if 'mat' in glsl_type: + if 'x' in glsl_type: + return int(glsl_type[-3:][:1]) else: - return int(in_type[-1:]) + return int(glsl_type[-1:]) else: return 1 - def rows(in_type): - if 'vec' in in_type or 'mat' in in_type: - return int(in_type[-1:]) + def rows(glsl_type): + if 'vec' in glsl_type or 'mat' in glsl_type: + return int(glsl_type[-1:]) else: return 1 @@ -106,19 +106,19 @@ void main() [vertex data] % for idx, in_type in enumerate(in_types): % if idx == position_order - 1: - piglit_vertex/vec3/3 \ + piglit_vertex/float/vec3 \ % endif % for i in range(arrays[idx]): % for j in range(cols(in_type)): - value${idx}${'[{}]'.format(i) if arrays[idx] > 1 else ''}/${in_type}/${rows(in_type)}${'/{}'.format(j) if cols(in_type) > 1 else ''} \ + value${idx}${'[{}]'.format(i) if arrays[idx] > 1 else ''}/${gl_types[idx]}/${in_type}${'/{}'.format(j) if cols(in_type) > 1 else ''} \ % endfor % endfor % endfor % if position_order > len(in_types): - piglit_vertex/vec3/3\ + piglit_vertex/float/vec3\ % endif -% for d in range(len(dvalues)): +% for d in range(len(gl_types_values['double'])): % for vertex in ('-1.0 -1.0 0.0', ' 1.0 -1.0 0.0', ' 1.0 1.0 0.0', '-1.0 1.0 0.0'): % for idx, in_type in enumerate(in_types): % if idx == position_order - 1: @@ -127,7 +127,7 @@ void main() % for i in range(arrays[idx]): % for j in range(cols(in_type)): % for k in range(rows(in_type)): - ${dvalues[(d + (i * cols(in_type) + j) * rows(in_type) + k) % len(dvalues)] if in_type.startswith('d') else hvalues[(d + (i * cols(in_type) + j) * rows(in_type) + k) % len(hvalues)]} \ + ${gl_types_values[gl_types[idx]][(d + (i * cols(in_type) + j) * rows(in_type) + k) % len(gl_types_values[gl_types[idx]])]} \ % endfor \ % endfor @@ -141,14 +141,15 @@ void main() % endfor [test] -% for d in range(len(dvalues)): +% for d in range(len(gl_types_values['double'])): % for idx, in_type in enumerate(in_types): % for i in range(arrays[idx]): uniform ${in_type} expected${idx}${'[{}]'.format(i) if arrays[idx] > 1 else ''}\ % for j in range(cols(in_type)): % for k in range(rows(in_type)): - ${dvalues[(d + (i * cols(in_type) + j) * rows(in_type) + k) % len(dvalues)] if in_type.startswith('d') else hvalues[(d + (i * cols(in_type) + j) * rows(in_type) + k) % len(hvalues)]}\ + ## Careful: these are the values for the VBO type, not the uniform type. If we use the hex format they should match or the run will fail. + ${gl_types_values[gl_types[idx]][(d + (i * cols(in_type) + j) * rows(in_type) + k) % len(gl_types_values[gl_types[idx]])]}\ % endfor % endfor diff --git a/tests/util/piglit-dispatch.h b/tests/util/piglit-dispatch.h index cca7d59..f28ce4d 100644 --- a/tests/util/piglit-dispatch.h +++ b/tests/util/piglit-dispatch.h @@ -92,6 +92,7 @@ typedef short GLshort; typedef unsigned char GLubyte; typedef unsigned short GLushort; typedef unsigned long GLulong; +typedef unsigned short GLhalf; typedef float GLfloat; typedef float GLclampf; typedef double GLdouble; diff --git a/tests/util/piglit-vbo.cpp b/tests/util/piglit-vbo.cpp index 274779f..6744b1e 100644 --- a/tests/util/piglit-vbo.cpp +++ b/tests/util/piglit-vbo.cpp @@ -28,7 +28,7 @@ * tests using a columnar text format, for example: * * \verbatim - * vertex/vec3/3 foo/uint/1 bar[0]/int/1 bar[1]/int/1 + * vertex/double/vec3 foo/uint/uint bar[0]/int/int bar[1]/int/int * 0.0 0.0 0.0 10 0 0 # comment * 0.0 1.0 0.0 5 1 1 * 1.0 1.0 0.0 0 0 1 @@ -36,22 +36,21 @@ * * The format consists of a row of column headers followed by any * number of rows of data. Each column header has the form - * "ATTRNAME[ARRAY_INDEX]/TYPE/COUNT/MATRIX_COLUMN", where ATTRNAME is - * the name of the vertex attribute to be bound to this column, - * ARRAY_INDEX is the index, TYPE is the GLSL type of data that - * follows ("float", "double", "int", "uint" or any derived type like - * vec2, dmat4, etc.), COUNT is the vector length of the data - * (e.g. "3" for vec3 data or "2" for mat4x2) and MATRIX_COLUMN is the - * column number of the data in case of being a matrix. [ARRAY_INDEX] - * is optional and needs to be specified only in case of array - * attributes. COUNT is a redundant value that is already specified in - * the data type but that has been kept for backward - * compatibility. MATRIX_COLUMN doesn't need to be specified if it is - * not a matrix column as in the example before. So another example, - * if you want to specify the data of a mat2x3: + * "ATTRNAME[ARRAY_INDEX]/GL_TYPE/GLSL_TYPE/MATRIX_COLUMN", where + * ATTRNAME is the name of the vertex attribute to be bound to this + * column, ARRAY_INDEX is the index, GL_TYPE is the GL type of data + * that follows ("half", "float", "double", "byte", "ubyte", "short", + * "ushort", "int" or "uint"), GLSL_TYPE is the GLSL type of the data + * ("int", "uint", "float", "double", "ivec"*, "uvec"*, "vec"*, + * "dvec"*, "mat"*, "dmat"*) and MATRIX_COLUMN is the column number of + * the data in case of being a matrix. [ARRAY_INDEX] is optional and + * needs to be specified only in case of array + * attributes. MATRIX_COLUMN doesn't need to be specified if it is not + * a matrix column as in the example before. So another example, if + * you want to specify the data of a mat2x3: * * \verbatim - * foomatrix/mat2x3/3/0 foomatrix/mat2x3/3/1 + * foomatrix/float/mat2x3/0 foomatrix/float/mat2x3/1 * 0.0 1.0 2.0 3.0 4.0 5.0 * 6.0 7.0 8.0 9.0 10.0 11.0 * \endverbatim @@ -130,76 +129,136 @@ #include <string> #include <vector> #include <errno.h> +#include <limits.h> #include <ctype.h> #include "piglit-util.h" #include "piglit-util-gl.h" #include "piglit-vbo.h" + /** - * Currently all the attribute types we support (int, uint, and float) - * are 4 bytes in width. + * Convert a type name string to a GLenum. */ -const int ATTRIBUTE_SIZE = 4; +static bool +decode_type(const char *type, + GLenum *gl_type, size_t *gl_type_size, GLenum *glsl_type) +{ + assert(type); + assert(gl_type); + assert(gl_type_size); + + static struct type_table_entry { + const char *type; /* NULL means end of table */ + GLenum gl_type; + size_t gl_type_size; + GLenum glsl_type; + } const type_table[] = { + { "byte", GL_BYTE, 1, GL_INT }, + { "ubyte", GL_UNSIGNED_BYTE, 1, GL_UNSIGNED_INT }, + { "short", GL_SHORT, 2, GL_INT }, + { "ushort", GL_UNSIGNED_SHORT, 2, GL_UNSIGNED_INT }, + { "int", GL_INT, 4, GL_INT }, + { "uint", GL_UNSIGNED_INT, 4, GL_UNSIGNED_INT }, + { "half", GL_HALF_FLOAT, 2, GL_FLOAT }, + { "float", GL_FLOAT, 4, GL_FLOAT }, + { "double", GL_DOUBLE, 8, GL_DOUBLE }, + { NULL, 0, 0, 0 }, + }; + + + for (int i = 0; type_table[i].type; ++i) { + if (0 == strcmp(type, type_table[i].type)) { + *gl_type = type_table[i].gl_type; + *gl_type_size = type_table[i].gl_type_size; + if (glsl_type) + *glsl_type = type_table[i].glsl_type; + return true; + } + } + + return false; +} /** - * Convert a type name string to a GLenum. + * Convert a GLSL type name string to its basic GLenum type. */ -GLenum -decode_type(const char *type, size_t *rows, size_t *cols) +static bool +decode_glsl_type(const char *type, + GLenum *glsl_type, size_t *rows, size_t *cols, char **endptr) { + assert(glsl_type); + assert(rows); + assert(cols); + assert(endptr); + + if (isdigit(type[0])) { + *rows = strtoul(type, endptr, 10); + *cols = 1; + *glsl_type = 0; + return true; + } + static struct type_table_entry { const char *type; /* NULL means end of table */ - GLenum enum_value; + GLenum glsl_type; } const type_table[] = { - { "int", GL_INT }, - { "uint", GL_UNSIGNED_INT }, - { "float", GL_FLOAT }, - { "double", GL_DOUBLE }, - { "ivec", GL_INT }, - { "uvec", GL_UNSIGNED_INT }, - { "vec", GL_FLOAT }, - { "dvec", GL_DOUBLE }, - { "mat", GL_FLOAT }, - { "dmat", GL_DOUBLE }, - { NULL, 0 } + { "int", GL_INT }, + { "uint", GL_UNSIGNED_INT }, + { "float", GL_FLOAT }, + { "double", GL_DOUBLE }, + { "ivec", GL_INT }, + { "uvec", GL_UNSIGNED_INT }, + { "vec", GL_FLOAT }, + { "dvec", GL_DOUBLE }, + { "mat", GL_FLOAT }, + { "dmat", GL_DOUBLE }, + { NULL, 0 } }; - for (int i = 0; type_table[i].type; ++i) { - if (0 == strncmp(type, type_table[i].type, strlen(type_table[i].type))) { + const size_t type_len = strlen(type_table[i].type); + if (0 == strncmp(type, type_table[i].type, type_len)) { + *endptr = const_cast<char *>(&type[type_len]); + /* In case of vectors or matrices, let's - * calculate rows and columns, if needed. + * calculate rows and columns. */ - if (i > 3 && (rows || cols)) { - size_t type_len = strlen(type); - size_t the_rows = type[type_len - 1] - '0'; - if (rows) - *rows = the_rows; - if (cols) { - /* In case of matrices, let's - * calculate the columns. - */ - if (i > 7) - *cols = type[type_len - 2] == 'x' ? - type[type_len - 3] - '0' : the_rows; - else - *cols = 1; + if (i > 3) { + if (!isdigit(**endptr)) + goto cleanup; + *rows = **endptr - '0'; + ++*endptr; + + /* In case of matrices, let's + * calculate the rows. + */ + if (i > 7) { + *cols = *rows; + if (**endptr == 'x') { + if (!isdigit(*(++*endptr))) + goto cleanup; + *rows = **endptr - '0'; + ++*endptr; + } + } else { + *cols = 1; } } else { - if (rows) - *rows = 1; - if (cols) - *cols = 1; + *rows = 1; + *cols = 1; } - return type_table[i].enum_value; + *glsl_type = type_table[i].glsl_type; + return true; } } - printf("Unrecognized type: %s\n", type); - piglit_report_result(PIGLIT_FAIL); - return 0; +cleanup: + + *glsl_type = 0; + *endptr = const_cast<char *>(type); + return false; } @@ -214,29 +273,39 @@ public: void setup(size_t *offset, size_t stride) const; /** - * Data type of this attribute. + * GL data type of this attribute. */ GLenum data_type; /** - * Number of columns in the data type of this attribute. + * Size of the GL data type of this attribute. */ - size_t data_type_cols; + size_t data_type_size; /** - * Vector length of this attribute. + * GLSL data type of this attribute. */ - size_t count; + GLenum glsl_data_type; /** - * Index of the matrix column for this attribute. + * Index of the array for this attribute. */ - size_t matrix_index; + size_t array_index; /** - * Index of the array for this attribute. + * Number of columns of the GLSL data type of this attribute. */ - size_t array_index; + size_t cols; + + /** + * Number of rows of the GLSL data type of this attribute. + */ + size_t rows; + + /** + * Index of the matrix column for this attribute. + */ + size_t matrix_index; /** * Index of this vertex attribute in the linked program. @@ -248,7 +317,7 @@ public: /** * Build a vertex_attrib_description from a column header, by looking * up the vertex attribute in the linked program and interpreting the - * type and count parts of the header. + * type, dimensions and mattrix_column parts of the header. * * If there is a parse failure, print a description of the problem and * then exit with PIGLIT_FAIL. @@ -257,12 +326,12 @@ vertex_attrib_description::vertex_attrib_description(GLuint prog, const char *text) { /* Split the column header into - * name[array_index]/type/count/matrix_column fields. + * name[array_index]/type/dimensions/matrix_column fields. */ const char *first_slash = strchr(text, '/'); if (first_slash == NULL) { printf("Column headers must be in the form" - " name[array_index]/type/count/matrix_column.\n" + " name[array_index]/type/dimensions/matrix_column.\n" "Note: [array_index] and matrix_column are optional.\n" "Got: %s\n", text); @@ -291,17 +360,32 @@ vertex_attrib_description::vertex_attrib_description(GLuint prog, const char *second_slash = strchr(first_slash + 1, '/'); if (second_slash == NULL) { printf("Column headers must be in the form" - " name[array_index]/type/count/matrix_column.\n" + " name[array_index]/type/dimensions/matrix_column.\n" "Note: [array_index] and matrix_column are optional.\n" "Got: %s\n", text); piglit_report_result(PIGLIT_FAIL); } - std::string type_str(first_slash + 1, second_slash); - this->data_type = decode_type(type_str.c_str(), - &this->count, &this->data_type_cols); + char *endptr; - this->count = strtoul(second_slash + 1, &endptr, 10); + if (!decode_glsl_type(second_slash + 1, + &this->glsl_data_type, + &this->rows, &this->cols, + &endptr)) { + printf("Unrecognized GLSL type: %s\n", second_slash + 1); + piglit_report_result(PIGLIT_FAIL); + } + + std::string type_str(first_slash + 1, second_slash); + GLenum *glsl_data_type = this->glsl_data_type ? 0 + : &this->glsl_data_type; + + if (!decode_type(type_str.c_str(), + &this->data_type, &this->data_type_size, + glsl_data_type)) { + printf("Unrecognized GL type: %s\n", type_str.c_str()); + piglit_report_result(PIGLIT_FAIL); + } if (*endptr != '\0') { const char *third_slash = strchr(second_slash + 1, '/'); @@ -315,7 +399,7 @@ vertex_attrib_description::vertex_attrib_description(GLuint prog, if (*endptr != '\0') { printf("Column headers must be in the form" - " name[array_index]/type/count/matrix_column.\n" + " name[array_index]/type/dimensions/matrix_column.\n" "Note: [array_index] and matrix_column are optional.\n" "Got: %s\n", text); @@ -338,7 +422,7 @@ vertex_attrib_description::vertex_attrib_description(GLuint prog, * (b) skip itself if integer vertex attribute support is not * present. */ - if (this->data_type != GL_FLOAT && + if (this->glsl_data_type != GL_FLOAT && (piglit_is_gles() || (piglit_get_gl_version() < 30 && !piglit_is_extension_supported("GL_EXT_gpu_shader4")))) { @@ -347,8 +431,15 @@ vertex_attrib_description::vertex_attrib_description(GLuint prog, piglit_report_result(PIGLIT_FAIL); } - if (this->count < 1 || this->count > 4) { - printf("Count must be between 1 and 4. Got: %lu\n", (unsigned long) count); + if (this->rows < 1 || this->rows > 4) { + printf("Rows must be between 1 and 4. Got: %lu\n", + (unsigned long) this->rows); + piglit_report_result(PIGLIT_FAIL); + } + + if (this->cols < 1 || this->cols > 4) { + printf("Columns must be between 1 and 4. Got: %lu\n", + (unsigned long) this->cols); piglit_report_result(PIGLIT_FAIL); } } @@ -368,6 +459,15 @@ vertex_attrib_description::parse_datum(const char **text, void *data) const char *endptr; errno = 0; switch (this->data_type) { + case GL_HALF_FLOAT: { + unsigned short value = strtohf_hex(*text, &endptr); + if (errno == ERANGE) { + printf("Could not parse as half float\n"); + return false; + } + *((GLhalf *) data) = value; + break; + } case GL_FLOAT: { float value = strtof_hex(*text, &endptr); if (errno == ERANGE) { @@ -386,6 +486,42 @@ vertex_attrib_description::parse_datum(const char **text, void *data) const *((GLdouble *) data) = value; break; } + case GL_BYTE: { + long value = strtol_hex(*text, &endptr); + if (errno == ERANGE || value < SCHAR_MIN || value > SCHAR_MAX) { + printf("Could not parse as signed byte\n"); + return false; + } + *((GLbyte *) data) = (GLbyte) value; + break; + } + case GL_UNSIGNED_BYTE: { + unsigned long value = strtoul(*text, &endptr, 0); + if (errno == ERANGE || value > UCHAR_MAX) { + printf("Could not parse as unsigned byte\n"); + return false; + } + *((GLubyte *) data) = (GLubyte) value; + break; + } + case GL_SHORT: { + long value = strtol_hex(*text, &endptr); + if (errno == ERANGE || value < SHRT_MIN || value > SHRT_MAX) { + printf("Could not parse as signed short\n"); + return false; + } + *((GLshort *) data) = (GLshort) value; + break; + } + case GL_UNSIGNED_SHORT: { + unsigned long value = strtoul(*text, &endptr, 0); + if (errno == ERANGE || value > USHRT_MAX) { + printf("Could not parse as unsigned short\n"); + return false; + } + *((GLushort *) data) = (GLushort) value; + break; + } case GL_INT: { long value = strtol_hex(*text, &endptr); if (errno == ERANGE) { @@ -420,37 +556,56 @@ vertex_attrib_description::parse_datum(const char **text, void *data) const void vertex_attrib_description::setup(size_t *offset, size_t stride) const { - int attribute_size = ATTRIBUTE_SIZE; GLuint actual_index = this->index + this->matrix_index - + this->array_index * this->data_type_cols; - switch (this->data_type) { + + this->array_index * this->cols; + switch (this->glsl_data_type) { case GL_FLOAT: - glVertexAttribPointer(actual_index, this->count, + glVertexAttribPointer(actual_index, this->rows, this->data_type, GL_FALSE, stride, (void *) *offset); break; case GL_DOUBLE: - if (!piglit_is_extension_supported("GL_ARB_vertex_attrib_64bit")) { + if (piglit_is_gles() + || !piglit_is_extension_supported("GL_ARB_vertex_attrib_64bit")) { fprintf(stderr,"vertex_attrib_description fail. no 64-bit float support\n"); return; } - glVertexAttribLPointer(actual_index, this->count, + if (this->data_type != GL_DOUBLE) { + fprintf(stderr,"vertex_attrib_description fail. the GL" + " type must be 'GL_DOUBLE' and it is '%s'\n", + piglit_get_prim_name(this->data_type)); + return; + } + glVertexAttribLPointer(actual_index, this->rows, this->data_type, stride, (void *) *offset); - attribute_size *= 2; break; default: if (piglit_is_gles() && piglit_get_gl_version() < 30) { fprintf(stderr,"vertex_attrib_description fail. no int support\n"); return; } - glVertexAttribIPointer(actual_index, this->count, + switch (this->data_type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + break; + default: + fprintf(stderr,"vertex_attrib_description fail. the GL" + " type '%s' is incompatible\n", + piglit_get_prim_name(this->data_type)); + return; + } + glVertexAttribIPointer(actual_index, this->rows, this->data_type, stride, (void *) *offset); break; } glEnableVertexAttribArray(actual_index); - *offset += attribute_size * this->count; + *offset += this->rows * this->data_type_size; } @@ -526,7 +681,6 @@ vbo_data::parse_header_line(const std::string &line, GLuint prog) ++pos; } else { size_t column_header_end = pos; - int mul; while (column_header_end < line.size() && !isspace(line[column_header_end])) ++column_header_end; @@ -535,8 +689,7 @@ vbo_data::parse_header_line(const std::string &line, GLuint prog) vertex_attrib_description desc( prog, column_header.c_str()); attribs.push_back(desc); - mul = (desc.data_type == GL_DOUBLE) ? 2 : 1; - this->stride += ATTRIBUTE_SIZE * desc.count * mul; + this->stride += desc.rows * desc.data_type_size; pos = column_header_end + 1; } } @@ -559,8 +712,7 @@ vbo_data::parse_data_line(const std::string &line, unsigned int line_num) const char *line_ptr = line.c_str(); for (size_t i = 0; i < this->attribs.size(); ++i) { - for (size_t j = 0; j < this->attribs[i].count; ++j) { - int mul = (this->attribs[i].data_type == GL_DOUBLE) ? 2 : 1; + for (size_t j = 0; j < this->attribs[i].rows; ++j) { if (!this->attribs[i].parse_datum(&line_ptr, data_ptr)) { printf("At line %u of [vertex data] section\n", @@ -568,7 +720,7 @@ vbo_data::parse_data_line(const std::string &line, unsigned int line_num) printf("Offending text: %s\n", line_ptr); piglit_report_result(PIGLIT_FAIL); } - data_ptr += ATTRIBUTE_SIZE * mul; + data_ptr += this->attribs[i].data_type_size; } } -- 2.8.1 _______________________________________________ Piglit mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/piglit
