Generator which create test combinations of different vertex inputs types, including a double derived type. Note that this generator creates a big amount of test: ~6000.
v2: - Include tests with interleaved u/int derived types. - Values are never repeated in a shader variable to avoid identical array members or columns in the same matrix (Alejandro). Also, removed one redundant test. Acked-by: Dave Airlie <airl...@redhat.com> Signed-off-by: Andres Gomez <ago...@igalia.com> --- generated_tests/CMakeLists.txt | 9 + generated_tests/gen_vs_in_fp64.py | 398 +++++++++++++++++++++ generated_tests/templates/gen_vs_in_fp64/base.mako | 27 ++ .../columns_execution.vert.shader_test.mako | 41 +++ .../gen_vs_in_fp64/columns_shader.vert.mako | 17 + .../gen_vs_in_fp64/execution.vert.shader_test.mako | 32 ++ .../templates/gen_vs_in_fp64/execution_base.mako | 85 +++++ .../regular_execution.vert.shader_test.mako | 67 ++++ .../gen_vs_in_fp64/regular_shader.vert.mako | 19 + .../templates/gen_vs_in_fp64/shader.vert.mako | 16 + .../templates/gen_vs_in_fp64/shader_base.mako | 12 + .../execution/vs-dvec3-input.shader_test | 37 -- 12 files changed, 723 insertions(+), 37 deletions(-) create mode 100644 generated_tests/gen_vs_in_fp64.py create mode 100644 generated_tests/templates/gen_vs_in_fp64/base.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/columns_execution.vert.shader_test.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/columns_shader.vert.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/execution.vert.shader_test.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/execution_base.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/regular_execution.vert.shader_test.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/regular_shader.vert.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/shader.vert.mako create mode 100644 generated_tests/templates/gen_vs_in_fp64/shader_base.mako delete mode 100644 tests/spec/arb_vertex_attrib_64bit/execution/vs-dvec3-input.shader_test diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt index 1e69486..0b9048f 100644 --- a/generated_tests/CMakeLists.txt +++ b/generated_tests/CMakeLists.txt @@ -188,6 +188,14 @@ piglit_make_generated_tests( templates/gen_variable_index_write_tests/vs.shader_test.mako templates/gen_variable_index_write_tests/fs.shader_test.mako templates/gen_variable_index_write_tests/helpers.mako) +piglit_make_generated_tests( + vs_in_fp64.list + gen_vs_in_fp64.py + templates/gen_vs_in_fp64/base.mako + templates/gen_vs_in_fp64/execution.vert.shader_test.mako + templates/gen_vs_in_fp64/execution_base.mako + templates/gen_vs_in_fp64/shader.vert.mako + templates/gen_vs_in_fp64/shader_base.mako) # OpenCL Test generators piglit_make_generated_tests( @@ -238,6 +246,7 @@ add_custom_target(gen-gl-tests gen_extensions_defined.list vp-tex.list variable_index_write_tests.list + vs_in_fp64.list ) # Create a custom target for generating OpenCL tests diff --git a/generated_tests/gen_vs_in_fp64.py b/generated_tests/gen_vs_in_fp64.py new file mode 100644 index 0000000..04bb8de --- /dev/null +++ b/generated_tests/gen_vs_in_fp64.py @@ -0,0 +1,398 @@ +# coding=utf-8 +# +# Copyright © 2016 Intel Corporation +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice (including the next +# paragraph) shall be included in all copies or substantial portions of the +# Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. + +"""Generate fp64 vertex shader input tests.""" + +from __future__ import print_function, division, absolute_import +import abc +import argparse +import itertools +import os + +from templates import template_dir +from modules import utils + +TEMPLATES = template_dir(os.path.basename(os.path.splitext(__file__)[0])) + +# Hard limit so we don't generate useless tests that cannot be run in any existing HW. +MAX_VERTEX_ATTRIBS = 32 + +# pylint: disable=bad-whitespace,line-too-long +DOUBLE_INFS = ['0xfff0000000000000', # -inf + '0x7ff0000000000000'] # +inf + +DOUBLE_NEG_ZERO = ['0x8000000000000000'] # Negative underflow (-0.0) + +DOUBLE_POS_ZERO = ['0x0000000000000000'] # Positive underflow (+0.0) + +# Double values causing an underflow to zero in any other type +DOUBLE_DENORMAL_VALUES = ['0x800fffffffffffff', # Negative maximum denormalized -- Denormalized may be flushed to 0 + '0x8000000000000001', # Negative minimum denormalized -- Denormalized may be flushed to 0 + '0x0000000000000001', # Positive minimum denormalized -- Denormalized may be flushed to 0 + '0x000fffffffffffff'] # Positive maximum denormalized -- Denormalized may be flushed to 0 + +DOUBLE_NORMAL_VALUES = ['0xffefffffffffffff', # Negative maximum normalized + '0xcb1e35ed24eb6496', # -7.23401345e+53 + '0xc8b1381a93a87849', # -1.5e+42 + '0xc7efffffefffffff', # Negative maximum float normalized + '0xc170000000000000', # -16777216.0 + '0xc014000000000000', # -5.0 + '0xbfff25ce60000000', # -1.9467300176620483 + '0x8010000000000000', # Negative minimum normalized + '0x0010000000000000', # Positive minimum normalized + '0x3fff25ce60000000', # +1.9467300176620483 + '0x4014000000000000', # +5.0 + '0x4170000000000000', # +16777216.0 + '0x47efffffefffffff', # Positive maximum float normalized + '0x48b1381a93a87849', # +1.5e+42 + '0x4b1e35ed24eb6496', # +7.23401345e+53 + '0x7fefffffffffffff'] # Positive maximum normalized + +DSCALAR_TYPES = ['double'] + +DVEC_TYPES = ['dvec2', 'dvec3', 'dvec4'] + +DMAT_TYPES = ['dmat2', 'dmat2x3', 'dmat2x4', + 'dmat3x2', 'dmat3', 'dmat3x4', + 'dmat4x2', 'dmat4x3', 'dmat4'] + +FSCALAR_TYPES = ['float'] + +FVEC_TYPES = ['vec2', 'vec3', 'vec4'] + +FMAT_TYPES = ['mat2', 'mat2x3', 'mat2x4', + 'mat3x2', 'mat3', 'mat3x4', + 'mat4x2', 'mat4x3', 'mat4'] + +ISCALAR_TYPES = ['int'] + +IVEC_TYPES = ['ivec2', 'ivec3', 'ivec4'] + +USCALAR_TYPES = ['uint'] + +UVEC_TYPES = ['uvec2', 'uvec3', 'uvec4'] + +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 + + +# pylint: enable=bad-whitespace,line-too-long + + +class TestTuple(object): + """A float64 derived and other type derived tuple to generate the + needed conversion tests. + """ + + @staticmethod + def rows(in_type): + """Calculates the amounts of rows in a basic GLSL type.""" + if 'vec' in in_type or 'mat' in in_type: + return int(in_type[-1:]) + else: + return 1 + + @staticmethod + def cols(in_type): + """Calculates the amounts of columns in a basic GLSL type.""" + if 'mat' in in_type: + if 'x' in in_type: + return int(in_type[-3:][:1]) + else: + return int(in_type[-1:]) + else: + return 1 + + @staticmethod + def get_dir_name(ver): + """Returns the directory name to save tests given a GLSL version.""" + + assert isinstance(ver, str) + if ver.startswith('GL_'): + feature_dir = ver[3:].lower() + else: + feature_dir = 'glsl-{}.{}'.format(ver[0], ver[1:]) + + return os.path.join('spec', feature_dir, 'execution', + 'vs_in') + + def __init__(self, ver, names_only): + assert isinstance(ver, str) + assert isinstance(names_only, bool) + + self._ver = ver + self._names_only = names_only + self._filenames = [] + + @abc.abstractmethod + def _generate(self): + """Generates the test files for conversions to float64.""" + + @property + def filenames(self): + """Returns the test file names this tuple will generate.""" + if self._filenames == []: + tmp = self._names_only + self._names_only = True + self.generate_test_files() + self._names_only = tmp + return self._filenames + + def generate_test_files(self): + """Generate the GLSL parser tests.""" + self._filenames = [] + + self._generate() + + +class RegularTestTuple(TestTuple): + """Derived class for conversion tests using regular values within the + edges of the used types. + """ + + @staticmethod + def create_in_types_array(*types_arrays): + """Creates vertex input combinations.""" + + in_types_array = [] + for product_item in itertools.product(*types_arrays): + in_types_array.append(product_item) + + return in_types_array + + @staticmethod + def create_tests(glsl_vers, in_types_array, position_orders, arrays_array, names_only): + """Creates combinations for flat qualifier tests.""" + + assert isinstance(glsl_vers, list) + assert isinstance(in_types_array, list) + assert isinstance(position_orders, list) + assert isinstance(arrays_array, list) + assert isinstance(names_only, bool) + + if not names_only: + for ver in glsl_vers: + utils.safe_makedirs(TestTuple.get_dir_name(ver)) + + for in_types, position_order, arrays, ver in itertools.product(in_types_array, + position_orders, + arrays_array, + glsl_vers): + num_vs_in = 1 # We use an additional vec3 piglit_vertex input + for idx, in_type in enumerate(in_types): + if ((in_type.startswith('dvec') or in_type.startswith('dmat')) + and (in_type.endswith('3') or in_type.endswith('4'))): + multiplier = 2 + else: + multiplier = 1 + num_vs_in += TestTuple.cols(in_type) * arrays[idx] * multiplier + # dvec* and dmat* didn't appear in GLSL until 4.20 + if (in_type.startswith('dvec') or in_type.startswith('dmat')) and ver == '410': + ver = '420' + # Skip the test if it needs too many inputs + if num_vs_in > MAX_VERTEX_ATTRIBS: + continue + + yield ver, in_types, position_order, arrays, num_vs_in, names_only + + @staticmethod + def all_tests(names_only): + """Creates all the combinations for flat qualifier tests.""" + + assert isinstance(names_only, bool) + + # We need additional directories for GLSL 420 + if not names_only: + utils.safe_makedirs(TestTuple.get_dir_name('420')) + for test_args in (list(RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + DSCALAR_TYPES + DVEC_TYPES + DMAT_TYPES, + FSCALAR_TYPES + FVEC_TYPES + FMAT_TYPES + + ISCALAR_TYPES + IVEC_TYPES + + USCALAR_TYPES + UVEC_TYPES), + [1, 2, 3], + [[1, 1], [1, 3], [5, 1], [5, 3]], + names_only))): + yield RegularTestTuple(*test_args) + for test_args in (list(RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + FSCALAR_TYPES + FVEC_TYPES + FMAT_TYPES + + ISCALAR_TYPES + IVEC_TYPES + + USCALAR_TYPES + UVEC_TYPES, + DSCALAR_TYPES + DVEC_TYPES + DMAT_TYPES), + [1, 2, 3], + [[1, 1], [1, 2], [3, 1], [3, 2]], + names_only))): + yield RegularTestTuple(*test_args) + for test_args in (list(RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + DSCALAR_TYPES + DVEC_TYPES + DMAT_TYPES, + DSCALAR_TYPES + DVEC_TYPES + DMAT_TYPES), + [1, 2, 3], + [[1, 1], [1, 2], [3, 1], [3, 2]], + names_only))): + yield RegularTestTuple(*test_args) + for test_args in (list(RegularTestTuple.create_tests( + ['GL_ARB_vertex_attrib_64bit', '410'], + RegularTestTuple.create_in_types_array( + DSCALAR_TYPES + DVEC_TYPES + DMAT_TYPES), + [1, 2], + [[1], [5]], + names_only))): + yield RegularTestTuple(*test_args) + + def __init__(self, ver, in_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(position_order, int) + assert (position_order > 0) and (position_order - 1 <= len(in_types)) + assert isinstance(arrays, list) + assert isinstance(num_vs_in, int) and (num_vs_in <= MAX_VERTEX_ATTRIBS) + super(RegularTestTuple, self).__init__(ver, names_only) + + self._in_types = in_types + self._position_order = position_order + self._arrays = arrays + self._num_vs_in = num_vs_in + + def _generate(self): + """Generate GLSL parser tests.""" + + filename = os.path.join(TestTuple.get_dir_name(self._ver), 'vs-input') + for idx, in_type in enumerate(self._in_types): + if idx == self._position_order - 1: + filename += '-position' + filename += '-{}{}'.format( + in_type, '-array{}'.format( + self._arrays[idx]) if self._arrays[idx] - 1 else '') + if self._position_order > len(self._in_types): + filename += '-position' + filename += '.shader_test' + + self._filenames.append(filename) + + if not self._names_only: + with open(filename, 'w') as test_file: + test_file.write(TEMPLATES.get_template( + 'regular_execution.vert.shader_test.mako').render_unicode( + ver=self._ver, + in_types=self._in_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)) + + +class ColumnsTestTuple(TestTuple): + """Derived class for conversion tests using regular values within the + edges of the used types. + """ + + @staticmethod + def all_tests(names_only): + """Creates all the combinations for flat qualifier tests.""" + + assert isinstance(names_only, bool) + glsl_vers = ['GL_ARB_vertex_attrib_64bit', '420'] + + if not names_only: + for ver in glsl_vers: + utils.safe_makedirs(TestTuple.get_dir_name(ver)) + + for mat in DMAT_TYPES: + for columns in itertools.product(range(2), repeat=TestTuple.cols(mat)): + if (0 not in columns) or (1 not in columns): + continue + for ver in glsl_vers: + yield ColumnsTestTuple(ver, mat, columns, names_only) + + def __init__(self, ver, mat, columns, names_only): + assert ver in ('GL_ARB_vertex_attrib_64bit', '420') + super(ColumnsTestTuple, self).__init__(ver, names_only) + + self._mat = mat + self._columns = columns + + def _generate(self): + """Generate GLSL parser tests.""" + + filename = os.path.join(TestTuple.get_dir_name(self._ver), + 'vs-input-columns-{}'.format(self._mat)) + for idx, column in enumerate(self._columns): + if column == 1: + filename += '-{}'.format(idx) + filename += '.shader_test' + + self._filenames.append(filename) + + if not self._names_only: + with open(filename, 'w') as test_file: + test_file.write(TEMPLATES.get_template( + 'columns_execution.vert.shader_test.mako').render_unicode( + ver=self._ver, + mat=self._mat, + columns=self._columns, + dvalues=DOUBLE_NORMAL_VALUES + DOUBLE_POS_ZERO)) + + +def main(): + """Main function.""" + + parser = argparse.ArgumentParser( + description="Generate non-flat interpolation qualifier tests with fp64 types") + parser.add_argument( + '--names-only', + dest='names_only', + action='store_true', + default=False, + help="Don't output files, just generate a list of filenames to stdout") + args = parser.parse_args() + + for test in (list(RegularTestTuple.all_tests(args.names_only)) + + list(ColumnsTestTuple.all_tests(args.names_only))): + test.generate_test_files() + for filename in test.filenames: + print(filename) + + +if __name__ == '__main__': + main() diff --git a/generated_tests/templates/gen_vs_in_fp64/base.mako b/generated_tests/templates/gen_vs_in_fp64/base.mako new file mode 100644 index 0000000..fb00d8c --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/base.mako @@ -0,0 +1,27 @@ +## coding=utf-8 +<%def name="versioning()"><% + if ver == 'GL_ARB_vertex_attrib_64bit': + glsl_version_int = '150' + else: + glsl_version_int = ver + + glsl_version = '{}.{}'.format(glsl_version_int[0], glsl_version_int[1:3]) + + return (glsl_version, glsl_version_int) +%></%def>\ +<%def name="cols(in_type)"><% + if 'mat' in in_type: + if 'x' in in_type: + return int(in_type[-3:][:1]) + else: + return int(in_type[-1:]) + else: + return 1 +%></%def>\ +<%def name="rows(in_type)"><% + if 'vec' in in_type or 'mat' in in_type: + return int(in_type[-1:]) + else: + return 1 +%></%def>\ +${next.body()}\ diff --git a/generated_tests/templates/gen_vs_in_fp64/columns_execution.vert.shader_test.mako b/generated_tests/templates/gen_vs_in_fp64/columns_execution.vert.shader_test.mako new file mode 100644 index 0000000..d345653 --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/columns_execution.vert.shader_test.mako @@ -0,0 +1,41 @@ +## coding=utf-8 +<%inherit file="execution.vert.shader_test.mako"/>\ +<%! from six.moves import range %>\ +<%block name="vertex_data">\ +piglit_vertex/vec3/3\ +% for i in range(self.cols(mat)): + value/${mat}/${self.rows(mat)}${'/{}'.format(i) if self.cols(mat) > 1 else ''}\ +% endfor + +% for d in range(len(dvalues)): +% 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'): +${vertex} \ +% for i in range(self.cols(mat)): + \ +% for j in range(self.rows(mat)): + ${dvalues[(d + i * self.rows(mat) + j) % len(dvalues)]}\ +% endfor +% endfor + +% endfor +% endfor +</%block> +<%block name="test_commands">\ +% for d in range(len(dvalues)): + +uniform ${mat} expected\ +% for i in range(self.cols(mat)): +% for j in range(self.rows(mat)): + ${dvalues[(d + i * self.rows(mat) + j) % len(dvalues)]}\ +% endfor +% endfor + +clear color 0.0 0.0 1.0 0.0 +clear +draw arrays GL_TRIANGLE_FAN ${d * 4} 4 +probe all rgba 0.0 1.0 0.0 1.0 +% endfor +</%block> +<%block name="vertex_shader">\ +<%include file="columns_shader.vert.mako"/>\ +</%block> \ No newline at end of file diff --git a/generated_tests/templates/gen_vs_in_fp64/columns_shader.vert.mako b/generated_tests/templates/gen_vs_in_fp64/columns_shader.vert.mako new file mode 100644 index 0000000..c150121 --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/columns_shader.vert.mako @@ -0,0 +1,17 @@ +## coding=utf-8 +<%inherit file="shader.vert.mako"/>\ +<%block name="global_variables">\ +uniform ${mat} expected; + +in ${mat} value; +</%block> +<%block name="main">\ +% for idx, column in enumerate(columns): +% if column == 1: + if (value[${idx}] != expected[${idx}]) { + fs_color = RED; + return; + } +% endif +% endfor +</%block> diff --git a/generated_tests/templates/gen_vs_in_fp64/execution.vert.shader_test.mako b/generated_tests/templates/gen_vs_in_fp64/execution.vert.shader_test.mako new file mode 100644 index 0000000..fc70997 --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/execution.vert.shader_test.mako @@ -0,0 +1,32 @@ +## coding=utf-8 +<%inherit file="base.mako"/>\ +<% + (glsl_version, glsl_version_int) = self.versioning() +%>\ +[require] +GLSL >= ${glsl_version} +% if ver == 'GL_ARB_vertex_attrib_64bit': +GL_ARB_gpu_shader_fp64 +${ver} +% endif +<%block name="require"/>\ + +[vertex shader] +<%block name="vertex_shader"/>\ + +[fragment shader] +#version 150 + +in vec4 fs_color; +out vec4 color; + +void main() +{ + color = fs_color; +} + +[vertex data] +<%block name="vertex_data"/>\ + +[test]\ +<%block name="test_commands"/>\ diff --git a/generated_tests/templates/gen_vs_in_fp64/execution_base.mako b/generated_tests/templates/gen_vs_in_fp64/execution_base.mako new file mode 100644 index 0000000..b36f7a8 --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/execution_base.mako @@ -0,0 +1,85 @@ +## coding=utf-8 +<%inherit file="base.mako"/>\ +<% + (glsl_version, glsl_version_int) = self.versioning() + + def rows(in_type): + if 'vec' in in_type or 'mat' in in_type: + return int(in_type[-1:]) + else: + return 1 + + def cols(in_type): + if 'mat' in in_type: + if 'x' in in_type: + return int(in_type[-3:][:1]) + else: + return int(in_type[-1:]) + else: + return 1 +%>\ +<%! from six.moves import range %>\ +[require] +GLSL >= ${glsl_version} +% if ver == 'GL_ARB_vertex_attrib_64bit': +GL_ARB_gpu_shader_fp64 +${ver} +% endif +GL_MAX_VERTEX_ATTRIBS >= ${num_vs_in} +${next.body()}\ +[vertex data] +% for idx, in_type in enumerate(in_types): +% if idx == position_order - 1: +piglit_vertex/vec3/3 \ +% 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 ''} \ +% endfor +% endfor +% endfor +% if position_order > len(in_types): +piglit_vertex/vec3/3\ +% endif + +% for d in range(len(dvalues)): +% 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: +${vertex} \ +% endif +% for i in range(arrays[idx]): +% for j in range(cols(in_type)): +% for k in range(rows(in_type)): +${dvalues[(d + k) % len(dvalues)] if in_type.startswith('d') else hvalues[(d + k) % 4]} \ +% endfor + \ +% endfor +% endfor +% endfor +% if position_order > len(in_types): +${vertex}\ +% endif + +% endfor +% endfor + +[test] +% for d in range(len(dvalues)): +% 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 + k) % len(dvalues)] if in_type.startswith('d') else hvalues[(d + k) % 4]}\ +% endfor +% endfor + +% endfor +% endfor +clear color 0.0 0.0 1.0 0.0 +clear +draw arrays GL_TRIANGLE_FAN ${d * 4} 4 +probe all rgba 0.0 1.0 0.0 1.0 + +% endfor diff --git a/generated_tests/templates/gen_vs_in_fp64/regular_execution.vert.shader_test.mako b/generated_tests/templates/gen_vs_in_fp64/regular_execution.vert.shader_test.mako new file mode 100644 index 0000000..d3fd08c --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/regular_execution.vert.shader_test.mako @@ -0,0 +1,67 @@ +## coding=utf-8 +<%inherit file="execution.vert.shader_test.mako"/>\ +<%! from six.moves import range %>\ +<%block name="require">\ +GL_MAX_VERTEX_ATTRIBS >= ${num_vs_in} +</%block> +<%block name="vertex_data">\ +% for idx, in_type in enumerate(in_types): +% if idx == position_order - 1: +piglit_vertex/vec3/3 \ +% endif +% for i in range(arrays[idx]): +% for j in range(self.cols(in_type)): +value${idx}${'[{}]'.format(i) if arrays[idx] > 1 else ''}/${in_type}/${self.rows(in_type)}${'/{}'.format(j) if self.cols(in_type) > 1 else ''} \ +% endfor +% endfor +% endfor +% if position_order > len(in_types): +piglit_vertex/vec3/3\ +% endif + +% for d in range(len(dvalues)): +% 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: +${vertex} \ +% endif +% for i in range(arrays[idx]): +% for j in range(self.cols(in_type)): +% for k in range(self.rows(in_type)): +${dvalues[(d + (i * self.cols(in_type) + j) * self.rows(in_type) + k) % len(dvalues)] if in_type.startswith('d') else hvalues[(d + (i * self.cols(in_type) + j) * self.rows(in_type) + k) % len(hvalues)]} \ +% endfor + \ +% endfor +% endfor +% endfor +% if position_order > len(in_types): +${vertex}\ +% endif + +% endfor +% endfor +</%block> +<%block name="test_commands">\ +% for d in range(len(dvalues)): + +% 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(self.cols(in_type)): +% for k in range(self.rows(in_type)): + ${dvalues[(d + (i * self.cols(in_type) + j) * self.rows(in_type) + k) % len(dvalues)] if in_type.startswith('d') else hvalues[(d + (i * self.cols(in_type) + j) * self.rows(in_type) + k) % len(hvalues)]}\ +% endfor +% endfor + +% endfor +% endfor +clear color 0.0 0.0 1.0 0.0 +clear +draw arrays GL_TRIANGLE_FAN ${d * 4} 4 +probe all rgba 0.0 1.0 0.0 1.0 +% endfor +</%block> +<%block name="vertex_shader">\ +<%include file="regular_shader.vert.mako"/>\ +</%block> + diff --git a/generated_tests/templates/gen_vs_in_fp64/regular_shader.vert.mako b/generated_tests/templates/gen_vs_in_fp64/regular_shader.vert.mako new file mode 100644 index 0000000..49fe2d6 --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/regular_shader.vert.mako @@ -0,0 +1,19 @@ +## coding=utf-8 +<%inherit file="shader.vert.mako"/>\ +<%block name="global_variables">\ +% for idx, in_type in enumerate(in_types): +uniform ${in_type} expected${idx}${'[{}]'.format(arrays[idx]) if arrays[idx] - 1 else ''}; +% endfor + +% for idx, in_type in enumerate(in_types): +in ${in_type} value${idx}${'[{}]'.format(arrays[idx]) if arrays[idx] - 1 else ''}; +% endfor +</%block> +<%block name="main">\ +% for idx, in_type in enumerate(in_types): + if (value${idx} != expected${idx}) { + fs_color = RED; + return; + } +% endfor +</%block> diff --git a/generated_tests/templates/gen_vs_in_fp64/shader.vert.mako b/generated_tests/templates/gen_vs_in_fp64/shader.vert.mako new file mode 100644 index 0000000..3f80c71 --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/shader.vert.mako @@ -0,0 +1,16 @@ +## coding=utf-8 +<%inherit file="shader_base.mako"/>\ +<%block name="global_variables"/>\ + +in vec3 piglit_vertex; +out vec4 fs_color; + +#define RED vec4(1.0, 0.0, 0.0, 1.0) +#define GREEN vec4(0.0, 1.0, 0.0, 1.0) + +void main() +{ + gl_Position = vec4(piglit_vertex, 1.0); +<%block name="main"/>\ + fs_color = GREEN; +} diff --git a/generated_tests/templates/gen_vs_in_fp64/shader_base.mako b/generated_tests/templates/gen_vs_in_fp64/shader_base.mako new file mode 100644 index 0000000..a86d5eb --- /dev/null +++ b/generated_tests/templates/gen_vs_in_fp64/shader_base.mako @@ -0,0 +1,12 @@ +## coding=utf-8 +<%inherit file="base.mako"/>\ +<% + (glsl_version, glsl_version_int) = self.versioning() +%>\ +#version ${glsl_version_int} +% if ver == 'GL_ARB_vertex_attrib_64bit': +#extension GL_ARB_gpu_shader_fp64 : require +#extension GL_ARB_vertex_attrib_64bit : require +% endif + +${next.body()}\ diff --git a/tests/spec/arb_vertex_attrib_64bit/execution/vs-dvec3-input.shader_test b/tests/spec/arb_vertex_attrib_64bit/execution/vs-dvec3-input.shader_test deleted file mode 100644 index d338c6c..0000000 --- a/tests/spec/arb_vertex_attrib_64bit/execution/vs-dvec3-input.shader_test +++ /dev/null @@ -1,37 +0,0 @@ -# test truncating a double holds precision -[require] -GLSL >= 1.50 -GL_ARB_gpu_shader_fp64 -GL_ARB_vertex_attrib_64bit - -[vertex shader] -#version 150 -#extension GL_ARB_gpu_shader_fp64 : require -#extension GL_ARB_vertex_attrib_64bit : require -in dvec3 vertex; -void main() -{ - gl_Position = vec4(vertex, 1.0); -} - -[fragment shader] -#version 150 -#extension GL_ARB_gpu_shader_fp64 : require - -void main() -{ - gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); -} - -[vertex data] -vertex/double/3 --1.0 -1.0 0.0 - 1.0 -1.0 0.0 - 1.0 1.0 0.0 --1.0 1.0 0.0 - -[test] -clear color 0.0 0.0 1.0 0.0 -clear -draw arrays GL_TRIANGLE_FAN 0 4 -probe rgba 0 0 0.0 1.0 0.0 1.0 -- 2.8.1 _______________________________________________ Piglit mailing list Piglit@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/piglit