[Piglit] [PATCH 1/4] arb_vertex_attrib_64bit: Adds double vertex input tests generator
Andres Gomez
agomez at igalia.com
Tue May 17 23:31:54 UTC 2016
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.
Also, removed one redundant test.
Signed-off-by: Andres Gomez <agomez at igalia.com>
---
generated_tests/CMakeLists.txt | 9 +
generated_tests/gen_vs_in_fp64.py | 380 +++++++++++++++++++++
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, 705 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..fb7455f
--- /dev/null
+++ b/generated_tests/gen_vs_in_fp64.py
@@ -0,0 +1,380 @@
+# 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
+
+# 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),
+ [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,
+ 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,
+ 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))
+
+
+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..6e251f5
--- /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 + 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 + 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..7c3a039
--- /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 + 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
+</%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 + 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
+</%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
More information about the Piglit
mailing list