[3/4] util: Add u/byte, u/short and half support to [vertex data]

Submitted by Andres Gomez on June 9, 2016, 9:27 p.m.

Details

Message ID 1465507625-10599-4-git-send-email-agomez@igalia.com
State Superseded
Headers show
Series "More additional tests for ARB_vertex_attrib_64bit extension" ( rev: 1 ) in Piglit

Not browsing as part of any series.

Commit Message

Andres Gomez June 9, 2016, 9:27 p.m.
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 <agomez@igalia.com>
---
 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(-)

Patch hide | download patch | download mbox

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;
 		}
 	}
 

Comments

On Fri, 2016-06-10 at 16:45 -0700, Dylan Baker wrote:

[snip]

> This is two pretty big changes together in one patch. I'd like the
> see
> the C changes and the generator changes split into separate patches.

Originally, I had the patch split in 2 because of this. In the end, I
decided to collapse both since, due to the changes in piglit-vbo.c, the
tests created by the generator would be failing. Hence, I decided to do
everything in an atomic commit.

Since this is a series that would be landing together, I suppose that's
not that important so I would create a v2 series with the patch split
once your series with the types module lands.

Thanks for checking this!