diff options
author | Dave Airlie <airlied@redhat.com> | 2016-06-20 14:07:16 +1000 |
---|---|---|
committer | Dave Airlie <airlied@redhat.com> | 2016-06-20 15:04:42 +1000 |
commit | c5f4dca84f88b26493040fee968f06dcf203c762 (patch) | |
tree | 0fa70844cec30dd2fba959d619b3961a34bdcefa | |
parent | 1b184489ec134e1934b5cc0fae50b4b0d0f56d53 (diff) |
arb_gpu_shader_int64: generate int64 conversion tests.arb_gpu_shader_int64
This is "ported" from the fp64 conversion generator, it
probably has a lot of stuff left over it shouldn't, but it
does generate the tests I expected to test 64-bit integer
conversions both implicit and explicit.
Signed-off-by: Dave Airlie <airlied@redhat.com>
15 files changed, 784 insertions, 0 deletions
diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt index 0b9048fb1..f50253406 100644 --- a/generated_tests/CMakeLists.txt +++ b/generated_tests/CMakeLists.txt @@ -153,6 +153,23 @@ piglit_make_generated_tests( templates/gen_conversion_fp64/shader_base.mako ) piglit_make_generated_tests( + conversion_int64.list + gen_conversion_int64.py + templates/gen_conversion_int64/base.mako + templates/gen_conversion_int64/compiler.frag.mako + templates/gen_conversion_int64/compiler.geom.mako + templates/gen_conversion_int64/compiler.vert.mako + templates/gen_conversion_int64/compiler_base.mako + templates/gen_conversion_int64/execution.frag.shader_test.mako + templates/gen_conversion_int64/execution.geom.shader_test.mako + templates/gen_conversion_int64/execution.vert.shader_test.mako + templates/gen_conversion_int64/execution_base.mako + templates/gen_conversion_int64/shader.frag.mako + templates/gen_conversion_int64/shader.geom.mako + templates/gen_conversion_int64/shader.vert.mako + templates/gen_conversion_int64/shader_base.mako + ) +piglit_make_generated_tests( shader_precision_tests.list gen_shader_precision_tests.py builtin_function.py @@ -247,6 +264,7 @@ add_custom_target(gen-gl-tests vp-tex.list variable_index_write_tests.list vs_in_fp64.list + conversion_int64.list ) # Create a custom target for generating OpenCL tests diff --git a/generated_tests/gen_conversion_int64.py b/generated_tests/gen_conversion_int64.py new file mode 100644 index 000000000..bbe38e9d9 --- /dev/null +++ b/generated_tests/gen_conversion_int64.py @@ -0,0 +1,569 @@ +# 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 int64 types conversion tests.""" + +from __future__ import print_function, division, absolute_import +import abc +import argparse +import itertools +import os +import struct + +import numpy as np + +from templates import template_dir +from modules import utils + +TEMPLATES = template_dir(os.path.basename(os.path.splitext(__file__)[0])) + +# pylint: disable=bad-whitespace,line-too-long,bad-continuation +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 = ['0x8010000000000000', # Negative minimum normalized + '0x0010000000000000'] # Positive minimum normalized + +# Double +/-inf +DOUBLE_FLOAT_INFS = ['0xc7effffff0000000', # Negative overflow (-inf) + '0x47effffff0000000'] # Positive overflow (+inf) + +DOUBLE_FLOAT_VALUES = ['0xc7efffffefffffff', # Negative maximum normalized + '0xc170000000000000', # -16777216.0 + '0xc014000000000000', # -5.0 + '0xbfff25ce60000000', # -1.9467300176620483 + '0xb80fffffe0000000', # Negative minimum normalized + '0xb69fffffffffffff', # Negative underflow + '0x369fffffffffffff', # Positive underflow + '0x380fffffe0000000', # Positive minimum normalized + '0x3fff25ce60000000', # +1.9467300176620483 + '0x4014000000000000', # +5.0 + '0x4170000000000000', # +16777216.0 + '0x47efffffefffffff'] # Positive maximum normalized + +DOUBLE_UINT_VALUES = ['0xbfeccccccccccccd', # -0.9 + #'0x8010000000000000', # Negative minimum normalized -- Already checked + #'0x800fffffffffffff', # Negative maximum denormalized -- Already checked + #'0x8000000000000001', # Negative minimum denormalized -- Already checked + #'0x8000000000000000', # Negative minimum (-0) -- Already checked + #'0x0000000000000000', # Positive minimum (+0) -- Already checked + '0x3fff25ce60000000', # +1.9467300176620483 + '0x4014000000000000', # +5.0 + '0x4170000000000000', # +16777216.0 + '0x41dfffffffc00000', # Signed int low frontier (+2147483647) + '0x41e0000000000000', # Signed int up frontier (+2147483648) + '0x41efffffffe00000'] # Maximum (+4294967295) + +DOUBLE_INT_VALUES = ['0xc1e0000000000000', # Minimum (-2147483648) + '0xc170000000000000', # -16777216.0 + '0xc014000000000000', # -5.0 + '0xbfff25ce60000000', # -1.9467300176620483 + #'0x8000000000000000', # Negative minimum (-0) -- Already checked + #'0x0000000000000000', # Minimum (+0) -- Already checked + '0x3fff25ce60000000', # +1.9467300176620483 + '0x4014000000000000', # +5.0 + '0x4170000000000000', # +16777216.0 + '0x41dfffffffc00000'] # Maximum (+2147483647) + +DOUBLE_BOOL_VALUES = [#'0x8010000000000000', # Minimum negative True value -- Already checked + #'0x0000000000000000', # False -- Already checked + #'0x0010000000000000', # Minimum positive True value -- Already checked + ] + +FLOAT_INFS = ['0xff800000', # -inf + '0x7f800000'] # +inf + +FLOAT_NEG_ZERO = ['0x80000000'] # Negative underflow (-0.0) + +FLOAT_POS_ZERO = ['0x00000000'] # Positive underflow (+0.0) + +FLOAT_NEG_VALUES = ['0xcb800000', # -16777216.0 + '0xc0a00000', # -5.0 + '0xbff92e73', # -1.9467300176620483 + '0x80800000'] # Negative minimum normalized + +FLOAT_POS_VALUES = [#'0x807fffff', # Negative maximum denormalized -- Denormalized may be flushed to 0 + #'0x80000001', # Negative minimum denormalized -- Denormalized may be flushed to 0 + #'0x00000001', # Positive minimum denormalized -- Denormalized may be flushed to 0 + #'0x007fffff', # Positive maximum denormalized -- Denormalized may be flushed to 0 + '0x00800000', # Positive minimum normalized + '0x3ff92e73', # +1.9467300176620483 + '0x40a00000', # +5.0 + '0x4b800000'] # +16777216.0 + +UINT_VALUES = ['0', # Minimum + '5', + '2147483647', # Signed int low frontier + '2147483648', # Signed int up frontier + '4294967295'] # Maximum + +INT_VALUES = ['-2147483648', # Minimum + '-5', + '-1', + '0', + '1', + '5', + '2147483647'] # Maximum + +UINT64_VALUES = ['0', # Minimum + '5', + '18446744073709551615'] # Maximum + +INT64_VALUES = ['-9223372036854775806',# Minimum + '-5', + '0' + '5', + '9223372036854775807'] # Maximum + +BOOL_VALUES = ['0', # False + '1'] # True +# pylint: enable=bad-whitespace,line-too-long,bad-continuation + +def get_dir_name(ver, test_type): + """Returns the directory name to save tests given a GLSL version and a + test type. + """ + + assert isinstance(ver, str) + assert isinstance(test_type, 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, test_type, + 'conversion') + + +class TestTuple(object): + """A float64 derived and other type derived tuple to generate the + needed conversion tests. + """ + + @staticmethod + def float_to_hex(fvalue): + """Returns the hexadecimal representation from a float32 value.""" + assert isinstance(fvalue, np.float32) + return hex(struct.unpack('<I', struct.pack('<f', fvalue))[0]) + + @staticmethod + def double_to_hex(fvalue): + """Returns the hexadecimal representation from a float64 value.""" + assert isinstance(fvalue, float) + return hex(struct.unpack('<Q', struct.pack('<d', fvalue))[0]).rstrip("L") + + @staticmethod + def hex_to_float(hstr): + """Returns a float32 value from its hexadecimal representation.""" + assert isinstance(hstr, str) + return struct.unpack('<f', struct.pack('<I', int(hstr, 16)))[0] + + @staticmethod + def hex_to_double(hstr): + """Returns a float64 value from its hexadecimal representation.""" + assert isinstance(hstr, str) + return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0] + + @staticmethod + def hex_to_int64(hstr): + """Returns a 64-bit integer value from its hexadecimal representation.""" + + assert isinstance(hstr, str) + return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0] + + @staticmethod + def float_hex_to_int64(hstr): + """Returns the float64 hexadecimal representation from a float32 + hexadecimal representation. + """ + assert isinstance(hstr, str) + double_value = TestTuple.hex_to_float(hstr) + return str(int(double_value)) + + @staticmethod + def float_hex_to_uint64(hstr): + """Returns the float64 hexadecimal representation from a float32 + hexadecimal representation. + """ + assert isinstance(hstr, str) + double_value = TestTuple.hex_to_float(hstr) + int_value = int(double_value) & 0xfffffffffffffff + return struct.unpack('<Q', struct.pack('<q', int_value))[0] + + @staticmethod + def double_hex_to_int64(hstr): + """Returns the float64 hexadecimal representation from a float32 + hexadecimal representation. + """ + assert isinstance(hstr, str) + double_value = TestTuple.hex_to_double(hstr) + return str(int(double_value)) + + @staticmethod + def double_hex_to_uint64(hstr): + """Returns the float64 hexadecimal representation from a float32 + hexadecimal representation. + """ + assert isinstance(hstr, str) + double_value = TestTuple.hex_to_double(hstr) + int_value = int(double_value) & 0xfffffffffffffff + return struct.unpack('<Q', struct.pack('<q', int_value))[0] + + @staticmethod + def int_str_to_int64_str(istr): + """Returns a int64 string from an int32 string.""" + assert isinstance(istr, str) + return str((istr)) + + @staticmethod + def int64_to_bool_str(hstr): + """Returns a bool string from a int64.""" + assert isinstance(hstr, str) + return '1' if int(hstr) != 0 else '0' + + @staticmethod + def int64_to_int_str(int64_val): + """Returns an int32 string from a float64 hexadecimal + representation. + """ + return struct.unpack('<i', struct.pack('<L', int(int64_val) & 0xffffffff))[0] + + @staticmethod + def int64_to_uint_str(int64_val): + """Returns an uint32 string from a float64 hexadecimal + representation. + """ + return struct.unpack('<i', struct.pack('<L', int(int64_val) & 0xffffffff))[0] + + @staticmethod + def int64_to_float_str(hstr): + """Returns the float32 hexadecimal representation from a float64 + hexadecimal representation. + """ + assert isinstance(hstr, str) + float_double = np.float32(hstr); + return TestTuple.float_to_hex(float_double) + + @staticmethod + def int64_to_double_str(hstr): + """Returns the float64 hexadecimal representation from a int64 + hexadecimal representation. + """ + assert isinstance(hstr, str) + float_double = np.float64(hstr); + return TestTuple.double_to_hex(float_double) + + def __init__(self, ver, stage, + first_dimension, second_dimension, + basic_type, output_type, names_only): + assert stage in ('vert', 'geom', 'frag') + assert first_dimension in ('1', '2', '3', '4') + assert second_dimension in ('1', '2', '3', '4') + assert isinstance(names_only, bool) + + self._ver = ver + self._stage = stage + self._basic_type = basic_type + self._names_only = names_only + self._output_type = output_type + self._conversion_type = '' + self._uniform_type = '' + self._amount = int(first_dimension) * int(second_dimension) + self._filenames = [] + + if first_dimension != '1': + dimensional_type = 'mat' + first_dimension + if first_dimension != second_dimension: + dimensional_type += 'x' + second_dimension + elif second_dimension != '1': + dimensional_type = 'vec' + second_dimension + else: + dimensional_type = '' + + if dimensional_type == '': + if basic_type == 'b': + self._conversion_type = 'bool' + self._uniform_type = 'int' + elif basic_type == 'i': + self._conversion_type = 'int' + elif basic_type == 'u': + self._conversion_type = 'uint' + elif basic_type == 'f': + self._conversion_type = 'float' + elif basic_type == 'd': + self._conversion_type = 'double' + + if output_type == 'u64': + self._bit64_type = 'uint64_t' + elif output_type == 'i64': + self._bit64_type = 'int64_t' + if self._uniform_type == '': + self._uniform_type = self._conversion_type + else: + self._conversion_type = (basic_type if basic_type != 'f' else '') + dimensional_type + if basic_type == 'b': + self._uniform_type = 'i' + dimensional_type + else: + self._uniform_type = self._conversion_type + if output_type == 'u64': + self._bit64_type = 'u64' + dimensional_type + elif output_type == 'i64': + self._bit64_type = 'i64' + dimensional_type + + @abc.abstractmethod + def _gen_to_bit64(self): + """Generates the test files for conversions to 64-bit integer.""" + + @abc.abstractmethod + def _gen_from_bit64(self): + """Generates the test files for conversions from 64-bit integers.""" + + @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._gen_to_bit64() + self._gen_from_bit64() + + +class RegularTestTuple(TestTuple): + """Derived class for conversion tests using regular values within the + edges of the used types. + """ + + @staticmethod + def all_tests(names_only): + """Returns all the possible contained conversion test instances.""" + + assert isinstance(names_only, bool) + stages = ['frag'] #, 'geom', 'frag'] + dimensions = ['1', '2', '3', '4'] + basic_types = ['b', 'u', 'i', 'f', 'd'] + glsl_ver = ['GL_ARB_gpu_shader_int64'] + output_types = ['i64', 'u64'] + + if not names_only: + test_types = ['compiler', 'execution'] + for ver, test_type in itertools.product(glsl_ver, test_types): + utils.safe_makedirs(get_dir_name(ver, test_type)) + + for ver, stage, second_dimension, basic_type, output_type in itertools.product( + glsl_ver, + stages, + dimensions, + basic_types, output_types): + first_dimension = '1' + if not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f')): + yield RegularTestTuple(ver, stage, + first_dimension, second_dimension, + basic_type, output_type, names_only) + + def __init__(self, ver, stage, + first_dimension, second_dimension, + basic_type, output_type, names_only): + assert ver in ('GL_ARB_gpu_shader_int64') + assert basic_type in ('b', 'u', 'i', 'f', 'd') + assert not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f')) + assert output_type in ('i64', 'u64') + super(RegularTestTuple, self).__init__(ver, stage, + first_dimension, second_dimension, + basic_type, output_type, names_only) + + def _gen_comp_test(self, from_type, to_type, converted_from): + filename = os.path.join( + get_dir_name(self._ver, 'compiler'), + '{}-conversion-implicit-{}-{}-bad.{}'.format(self._stage, from_type, to_type, + self._stage)) + + self._filenames.append(filename) + + if not self._names_only: + with open(filename, 'w') as test_file: + test_file.write(TEMPLATES.get_template( + 'compiler.{}.mako'.format(self._stage)).render_unicode( + ver=self._ver, + from_type=from_type, + to_type=to_type, + converted_from=converted_from)) + + def _gen_exec_test(self, from_type, to_type, + uniform_from_type, uniform_to_type, + explicit, converted_from, conversions): + filename = os.path.join( + get_dir_name(self._ver, 'execution'), + '{}-conversion-{}-{}-{}.shader_test'.format(self._stage, explicit, + from_type, to_type)) + + self._filenames.append(filename) + + if not self._names_only: + with open(filename, 'w') as test_file: + test_file.write(TEMPLATES.get_template( + 'execution.{}.shader_test.mako'.format(self._stage)).render_unicode( + ver=self._ver, + amount=self._amount, + from_type=from_type, + to_type=to_type, + converted_from=converted_from, + uniform_from_type=uniform_from_type, + uniform_to_type=uniform_to_type, + conversions=conversions)) + + def _gen_to_bit64(self): + converted_from = 'from' + explicit = 'implicit' + + if self._basic_type == 'b': + explicit = 'explicit' + self._gen_comp_test(self._conversion_type, self._bit64_type, + converted_from) + converted_from = self._bit64_type + '(from)' + conversion_values = BOOL_VALUES + conversion_function = TestTuple.int_str_to_int64_str + elif self._basic_type == 'i': + conversion_values = INT_VALUES + conversion_function = TestTuple.int_str_to_int64_str + elif self._basic_type == 'u': + if self._output_type == 'i64': + explicit = 'explicit' + self._gen_comp_test(self._conversion_type, self._bit64_type, + converted_from) + converted_from = self._bit64_type + '(from)' + conversion_values = UINT_VALUES + conversion_function = TestTuple.int_str_to_int64_str + elif self._basic_type == 'f': + explicit = 'explicit' + self._gen_comp_test(self._conversion_type, self._bit64_type, + converted_from) + converted_from = self._bit64_type + '(from)' + if self._output_type == 'i64': + conversion_values = FLOAT_POS_ZERO + FLOAT_NEG_ZERO + FLOAT_POS_VALUES + FLOAT_NEG_VALUES + conversion_function = TestTuple.float_hex_to_int64 + elif self._output_type == 'u64': + conversion_values = FLOAT_POS_ZERO + FLOAT_POS_VALUES + conversion_function = TestTuple.float_hex_to_uint64 + elif self._basic_type == 'd': + explicit = 'explicit' + self._gen_comp_test(self._conversion_type, self._bit64_type, + converted_from) + converted_from = self._bit64_type + '(from)' + if self._output_type == 'i64': + conversion_values = DOUBLE_INT_VALUES + conversion_function = TestTuple.double_hex_to_int64 + else: + conversion_values = DOUBLE_UINT_VALUES + conversion_function = TestTuple.double_hex_to_uint64 + + + conversions = [] + for value in conversion_values: + to_value = conversion_function(value) + item = {'from': value, 'to': to_value} + conversions.append(item) + + self._gen_exec_test(self._conversion_type, self._bit64_type, + self._uniform_type, self._bit64_type, + explicit, converted_from, conversions) + + def _gen_from_bit64(self): + converted_from = 'from' + explicit = 'implicit' + + if self._basic_type != 'd': + explicit = 'explicit' + self._gen_comp_test(self._bit64_type, self._conversion_type, + converted_from) + + converted_from = self._conversion_type + '(from)' + + if self._output_type == 'u64': + conversion_values = UINT64_VALUES + elif self._output_type == 'i64': + conversion_values = INT64_VALUES + + if self._basic_type == 'b': + conversion_function = TestTuple.int64_to_bool_str + elif self._basic_type == 'i': + conversion_function = TestTuple.int64_to_int_str + elif self._basic_type == 'u': + conversion_function = TestTuple.int64_to_uint_str + elif self._basic_type == 'f': + conversion_function = TestTuple.int64_to_float_str + elif self._basic_type == 'd': + conversion_function = TestTuple.int64_to_double_str + + conversions = [] + for value in conversion_values: + to_value = conversion_function(value) + item = {'from': value, 'to': to_value} + conversions.append(item) + + self._gen_exec_test(self._bit64_type, self._conversion_type, + self._bit64_type, self._uniform_type, + explicit, converted_from, conversions) + + +def main(): + """Main function.""" + + parser = argparse.ArgumentParser( + description="Generate shader tests that check the conversions from and " + "to int64") + 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() + + np.seterr(divide='ignore') + + for test in (list(RegularTestTuple.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_conversion_int64/base.mako b/generated_tests/templates/gen_conversion_int64/base.mako new file mode 100644 index 000000000..2d9162ee3 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/base.mako @@ -0,0 +1,12 @@ +## coding=utf-8 +<%def name="versioning()"><% + if ver == 'GL_ARB_gpu_shader_int64': + glsl_version_int = '400' + else: + glsl_version_int = ver + + glsl_version = '{}.{}'.format(glsl_version_int[0], glsl_version_int[1:3]) + + return (glsl_version, glsl_version_int) +%></%def>\ +${next.body()}\ diff --git a/generated_tests/templates/gen_conversion_int64/compiler.frag.mako b/generated_tests/templates/gen_conversion_int64/compiler.frag.mako new file mode 100644 index 000000000..2ae22df92 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/compiler.frag.mako @@ -0,0 +1,3 @@ +## coding=utf-8 +<%inherit file="compiler_base.mako"/>\ +<%include file="shader.frag.mako"/>\ diff --git a/generated_tests/templates/gen_conversion_int64/compiler.geom.mako b/generated_tests/templates/gen_conversion_int64/compiler.geom.mako new file mode 100644 index 000000000..1e2e340fb --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/compiler.geom.mako @@ -0,0 +1,3 @@ +## coding=utf-8 +<%inherit file="compiler_base.mako"/>\ +<%include file="shader.geom.mako"/>\ diff --git a/generated_tests/templates/gen_conversion_int64/compiler.vert.mako b/generated_tests/templates/gen_conversion_int64/compiler.vert.mako new file mode 100644 index 000000000..d9148f14c --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/compiler.vert.mako @@ -0,0 +1,3 @@ +## coding=utf-8 +<%inherit file="compiler_base.mako"/>\ +<%include file="shader.vert.mako"/>\ diff --git a/generated_tests/templates/gen_conversion_int64/compiler_base.mako b/generated_tests/templates/gen_conversion_int64/compiler_base.mako new file mode 100644 index 000000000..6eb9a9203 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/compiler_base.mako @@ -0,0 +1,25 @@ +## coding=utf-8 +<%inherit file="base.mako"/>\ +<% + (glsl_version, glsl_version_int) = self.versioning() +%>\ +/* [config] + * expect_result: fail + * glsl_version: ${glsl_version} +% if ver == 'GL_ARB_gpu_shader_int64': + * require_extensions: ${ver} + * [end config] + * + * ${ver} spec states: + * + * "No implicit conversions are + * provided to convert from unsigned to signed integer types, from + * floating-point to integer types, or from higher-precision to + * lower-precision types. There are no implicit array or structure + * conversions." +% else: + * [end config] +% endif + */ + +${next.body()}\ diff --git a/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako new file mode 100644 index 000000000..60507eed3 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako @@ -0,0 +1,7 @@ +## coding=utf-8 +<%inherit file="execution_base.mako"/>\ + +[vertex shader passthrough] + +[fragment shader] +<%include file="shader.frag.mako"/> diff --git a/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako new file mode 100644 index 000000000..a4d41a611 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako @@ -0,0 +1,27 @@ +## coding=utf-8 +<%inherit file="execution_base.mako"/>\ + +[vertex shader] +#version 400 + +in vec4 piglit_vertex; +out vec4 vertex_to_gs; + +void main() +{ + vertex_to_gs = piglit_vertex; +} + +[geometry shader] +<%include file="shader.geom.mako"/> +[fragment shader] +#version 400 + +in vec4 fs_color; +out vec4 color; + +void main() +{ + color = fs_color; +} + diff --git a/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako new file mode 100644 index 000000000..08657c4d0 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako @@ -0,0 +1,16 @@ +## coding=utf-8 +<%inherit file="execution_base.mako"/>\ + +[vertex shader] +<%include file="shader.vert.mako"/> +[fragment shader] +#version 400 + +in vec4 fs_color; +out vec4 color; + +void main() +{ + color = fs_color; +} + diff --git a/generated_tests/templates/gen_conversion_int64/execution_base.mako b/generated_tests/templates/gen_conversion_int64/execution_base.mako new file mode 100644 index 000000000..f6ea2e341 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/execution_base.mako @@ -0,0 +1,31 @@ +## coding=utf-8 +<%inherit file="base.mako"/>\ +<% + (glsl_version, glsl_version_int) = self.versioning() +%>\ +<%! from six.moves import range %>\ +[require] +GLSL >= ${glsl_version} +% if ver == 'GL_ARB_gpu_shader_int64': +${ver} +% endif +${next.body()}\ +[test] +clear color 0.0 0.0 0.0 0.0 + +% for conversion in conversions: +clear +uniform ${uniform_from_type} from \ +% for i in range(amount): +${conversion['from']} \ +% endfor + +uniform ${uniform_to_type} to \ +% for i in range(amount): +${conversion['to']} \ +% endfor + +draw rect -1 -1 2 2 +probe all rgba 0.0 1.0 0.0 1.0 + +% endfor diff --git a/generated_tests/templates/gen_conversion_int64/shader.frag.mako b/generated_tests/templates/gen_conversion_int64/shader.frag.mako new file mode 100644 index 000000000..7a8b07c4e --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/shader.frag.mako @@ -0,0 +1,16 @@ +## coding=utf-8 +<%inherit file="shader_base.mako"/>\ +uniform ${from_type} from; +uniform ${to_type} to; + +out vec4 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() +{ + ${to_type} converted = ${converted_from}; + bool match = converted == to; + color = match ? GREEN : RED; +} diff --git a/generated_tests/templates/gen_conversion_int64/shader.geom.mako b/generated_tests/templates/gen_conversion_int64/shader.geom.mako new file mode 100644 index 000000000..bf6406587 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/shader.geom.mako @@ -0,0 +1,25 @@ +## coding=utf-8 +<%inherit file="shader_base.mako"/>\ +layout(triangles) in; +layout(triangle_strip, max_vertices = 3) out; + +uniform ${from_type} from; +uniform ${to_type} to; + +in vec4 vertex_to_gs[3]; +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() +{ + ${to_type} converted = ${converted_from}; + bool match = converted == to; + fs_color = match ? GREEN : RED; + + for (int i = 0; i < 3; i++) { + gl_Position = vertex_to_gs[i]; + EmitVertex(); + } +} diff --git a/generated_tests/templates/gen_conversion_int64/shader.vert.mako b/generated_tests/templates/gen_conversion_int64/shader.vert.mako new file mode 100644 index 000000000..2f3553d87 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/shader.vert.mako @@ -0,0 +1,18 @@ +## coding=utf-8 +<%inherit file="shader_base.mako"/>\ +uniform ${from_type} from; +uniform ${to_type} to; + +in vec4 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 = piglit_vertex; + ${to_type} converted = ${converted_from}; + bool match = converted == to; + fs_color = match ? GREEN : RED; +} diff --git a/generated_tests/templates/gen_conversion_int64/shader_base.mako b/generated_tests/templates/gen_conversion_int64/shader_base.mako new file mode 100644 index 000000000..64ad98541 --- /dev/null +++ b/generated_tests/templates/gen_conversion_int64/shader_base.mako @@ -0,0 +1,11 @@ +## coding=utf-8 +<%inherit file="base.mako"/>\ +<% + (glsl_version, glsl_version_int) = self.versioning() +%>\ +#version ${glsl_version_int} +% if ver == 'GL_ARB_gpu_shader_int64': +#extension GL_ARB_gpu_shader_int64 : require +% endif + +${next.body()}\ |