[Piglit] [RFC 10/12] generators: combine gen_builtin_uniform_tests* generators
Dylan Baker
baker.dylan.c at gmail.com
Mon Dec 8 17:11:31 PST 2014
This patch combines the test generators for fp64 and pre fp64 builtin
types to use a single generator script.
It attempts to produce the exact same output as before the conversion.
Signed-off-by: Dylan Baker <dylanx.c.baker at intel.com>
---
generated_tests/CMakeLists.txt | 9 +-
generated_tests/builtins/glsl_types.py | 5 +-
generated_tests/gen_builtin_uniform_tests.py | 13 +
generated_tests/gen_builtin_uniform_tests_fp64.py | 654 ---------------------
.../gen_builtin_uniform_tests/cs.shader_test.mako | 3 +
.../gen_builtin_uniform_tests/fs.shader_test.mako | 3 +
.../gen_builtin_uniform_tests/gs.shader_test.mako | 3 +
.../templates/gen_builtin_uniform_tests/utils.mako | 12 +-
.../gen_builtin_uniform_tests/vs.shader_test.mako | 3 +
9 files changed, 36 insertions(+), 669 deletions(-)
delete mode 100644 generated_tests/gen_builtin_uniform_tests_fp64.py
diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
index 1f50318..76ee250 100644
--- a/generated_tests/CMakeLists.txt
+++ b/generated_tests/CMakeLists.txt
@@ -33,6 +33,7 @@ piglit_make_generated_tests(
builtin_uniform_tests.list
gen_builtin_uniform_tests.py
builtin_function.py
+ builtin_function_fp64.py
builtins/glsl_types.py
builtins/generators.py
builtins/math.py
@@ -117,13 +118,6 @@ piglit_make_generated_tests(
templates/gen_outerproduct_tests/template.shader_test.mako
)
piglit_make_generated_tests(
- builtin_uniform_tests_fp64.list
- gen_builtin_uniform_tests_fp64.py
- builtin_function_fp64.py
- builtins/glsl_types.py
- builtins/generators.py
- builtins/math.py)
-piglit_make_generated_tests(
shader_image_load_store_tests.list
gen_shader_image_load_store_tests.py)
@@ -160,7 +154,6 @@ add_custom_target(gen-gl-tests
shader_bit_encoding_tests.list
uniform-initializer_tests.list
interpolation-qualifier-built-in-variable.list
- builtin_uniform_tests_fp64.list
shader_image_load_store_tests.list
)
diff --git a/generated_tests/builtins/glsl_types.py b/generated_tests/builtins/glsl_types.py
index 038fcd7..d799acd 100644
--- a/generated_tests/builtins/glsl_types.py
+++ b/generated_tests/builtins/glsl_types.py
@@ -114,7 +114,10 @@ class GlslBuiltinType(object):
else:
return 'ivec{}'.format(self.num_rows)
elif self.is_matrix:
- return 'mat{0}x{1}'.format(self.num_cols, self.num_rows)
+ if self.base_type is GLSL_FLOAT:
+ return 'mat{0}x{1}'.format(self.num_cols, self.num_rows)
+ elif self.base_type is GLSL_DOUBLE:
+ return 'dmat{0}x{1}'.format(self.num_cols, self.num_rows)
else:
return str(self)
diff --git a/generated_tests/gen_builtin_uniform_tests.py b/generated_tests/gen_builtin_uniform_tests.py
index 05e16e2..7df2e7b 100644
--- a/generated_tests/gen_builtin_uniform_tests.py
+++ b/generated_tests/gen_builtin_uniform_tests.py
@@ -47,6 +47,7 @@ from __future__ import absolute_import, print_function
import os
import builtin_function
+import builtin_function_fp64
from builtins import glsl_types
from templates import template_dir
@@ -61,6 +62,8 @@ def _select_comparator(signature, use_if):
return 'bool'
elif signature.rettype.base_type == glsl_types.GLSL_FLOAT:
return 'float'
+ elif signature.rettype.base_type == glsl_types.GLSL_DOUBLE:
+ return 'double'
elif signature.rettype.base_type in (glsl_types.GLSL_INT,
glsl_types.GLSL_UINT):
return 'int'
@@ -131,10 +134,20 @@ def all_tests():
yield signature, test_vectors, True
+def fp64_tests():
+ for signature, test_vectors in builtin_function_fp64.test_suite.iteritems():
+ yield signature, test_vectors, False
+ if signature.rettype == glsl_types.GLSL_BOOL:
+ yield signature, test_vectors, True
+
+
def main():
for sig, vecs, use_if in all_tests():
for stage in ['vs', 'fs', 'gs', 'cs']:
generate(sig, vecs, use_if, stage)
+ for sig, vecs, use_if in fp64_tests():
+ for stage in ['vs', 'fs', 'gs']:
+ generate(sig, vecs, use_if, stage)
if __name__ == '__main__':
diff --git a/generated_tests/gen_builtin_uniform_tests_fp64.py b/generated_tests/gen_builtin_uniform_tests_fp64.py
deleted file mode 100644
index 120e4bb..0000000
--- a/generated_tests/gen_builtin_uniform_tests_fp64.py
+++ /dev/null
@@ -1,654 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2011 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 a set of shader_runner tests for every overloaded version
-# of every built-in function, based on the test vectors computed by
-# builtin_function.py.
-#
-# In each set of generated tests, one test exercises the built-in
-# function in each type of shader (vertex, geometry, and fragment).
-# In all cases, the inputs to the built-in function come from
-# uniforms, so that the effectiveness of the test won't be
-# circumvented by constant folding in the GLSL compiler.
-#
-# The tests operate by invoking the built-in function in the
-# appropriate shader, applying a scale and offset so that the expected
-# values are in the range [0.25, 0.75], and then outputting the result
-# as a solid rgba color, which is then checked using shader_runner's
-# "probe rgba" command.
-#
-# For built-in functions whose result type is a matrix, the test
-# checks one column at a time.
-#
-# This program outputs, to stdout, the name of each file it generates.
-# With the optional argument --names-only, it only outputs the names
-# of the files; it doesn't generate them.
-
-from __future__ import absolute_import
-import abc
-import optparse
-import os
-
-import numpy as np
-
-from builtins import glsl_types, generators
-import builtin_function_fp64
-
-
-def compute_offset_and_scale(test_vectors):
- """Compute scale and offset values such that for each result in
- test_vectors, (result - offset) * scale is in the range [0.25,
- 0.75], and scale is less than or equal to 1.0. These values are
- used to transform the test vectors so that their outputs can be
- stored in gl_FragColor without overflow.
- """
- low = min(np.min(tv.result) for tv in test_vectors)
- hi = max(np.max(tv.result) for tv in test_vectors)
- span = hi - low
- center = (hi + low)/2.0
- span *= 2.0
- if span < 1.0:
- span = 1.0
- offset = center - span/2.0
- scale = 1.0/span
- return offset, scale
-
-
-def shader_runner_format(values):
- """Format the given values for use in a shader_runner "uniform" or
- "probe rgba" command. Bools are converted to 0's and 1's, and
- values are separated by spaces.
- """
- transformed_values = []
- for value in values:
- if isinstance(value, (bool, np.bool_)):
- transformed_values.append(int(value))
- else:
- transformed_values.append(value)
- return ' '.join(repr(x) for x in transformed_values)
-
-
-def shader_runner_type(glsl_type):
- """Return the appropriate type name necessary for binding a
- uniform of the given type using shader_runner's "uniform" command.
- Boolean values and vectors are converted to ints, and square
- matrices are written in "matNxN" form.
- """
- if glsl_type.base_type == glsl_types.GLSL_BOOL:
- if glsl_type.is_scalar:
- return 'int'
- else:
- return 'ivec{0}'.format(glsl_type.num_rows)
- if glsl_type.is_matrix:
- return 'dmat{0}x{1}'.format(glsl_type.num_cols, glsl_type.num_rows)
- else:
- return str(glsl_type)
-
-
-class Comparator(object):
- """Base class which abstracts how we compare expected and actual
- values.
- """
- __metaclass__ = abc.ABCMeta
-
- def make_additional_declarations(self):
- """Return additional declarations, if any, that are needed in
- the shader program.
- """
- return ''
-
- @abc.abstractmethod
- def make_result_handler(self, invocation, output_var):
- """Return the shader code that is needed to produce the result
- and store it in output_var.
-
- invocation is the GLSL code to compute the output of the
- built-in function.
- """
-
- @abc.abstractmethod
- def make_result_test(self, test_num, test_vector):
- """Return the shader_runner test code that is needed to test a
- single test vector.
- """
-
- def testname_suffix(self):
- """Return a string to be used as a suffix on the test name to
- distinguish it from tests using other comparators."""
- return ''
-
-
-class BoolComparator(Comparator):
- """Comparator that tests functions returning bools and bvecs by
- converting them to floats.
-
- This comparator causes code to be generated in the following form:
-
- rettype result = func(args);
- output_var = vec4(result, 0.0, ...);
- """
- def __init__(self, signature):
- assert not signature.rettype.is_matrix
- self.__signature = signature
- self.__padding = 4 - signature.rettype.num_rows
-
- def make_result_handler(self, invocation, output_var):
- statements = ' {0} result = {1};\n'.format(
- self.__signature.rettype, invocation)
- statements += ' {0} = vec4(result{1});\n'.format(
- output_var, ', 0.0' * self.__padding)
- return statements
-
- def convert_to_float(self, value):
- """Convert the given vector or scalar value to a list of
- floats representing the expected color produced by the test.
- """
- value = value*1.0 # convert bools to floats
- value = generators.column_major_values(value)
- value += [0.0] * self.__padding
- return value
-
- def make_result_test(self, test_num, test_vector, draw):
- test = draw
- test += 'probe rgba {0} 0 {1}\n'.format(
- test_num,
- shader_runner_format(self.convert_to_float(test_vector.result)))
- return test
-
-
-class BoolIfComparator(Comparator):
- """Comparator that tests functions returning bools by evaluating
- them inside an if statement.
-
- This comparator causes code to be generated in the following form:
-
- if (func(args))
- output_var = vec4(1.0, 1.0, 0.0, 1.0);
- else
- output_var = vecp(0.0, 0.0, 1.0, 1.0);
- """
- def __init__(self, signature):
- assert signature.rettype == glsl_types.GLSL_BOOL
- self.__padding = 4 - signature.rettype.num_rows
-
- def make_result_handler(self, invocation, output_var):
- statements = ' if({0})\n'.format(invocation)
- statements += ' {0} = vec4(1.0, 1.0, 0.0, 1.0);\n'.format(
- output_var)
- statements += ' else\n'
- statements += ' {0} = vec4(0.0, 0.0, 1.0, 1.0);\n'.format(
- output_var)
- return statements
-
- def convert_to_float(self, value):
- """Convert the given vector or scalar value to a list of
- floats representing the expected color produced by the test.
- """
- if value:
- return [1.0, 1.0, 0.0, 1.0]
- else:
- return [0.0, 0.0, 1.0, 1.0]
-
- def make_result_test(self, test_num, test_vector, draw):
- test = draw
- test += 'probe rgba {0} 0 {1}\n'.format(
- test_num,
- shader_runner_format(self.convert_to_float(test_vector.result)))
- return test
-
- def testname_suffix(self):
- return '-using-if'
-
-
-class IntComparator(Comparator):
- """Comparator that tests functions returning ints or ivecs using a
- strict equality test.
-
- This comparator causes code to be generated in the following form:
-
- rettype result = func(args);
- output_var = result == expected ? vec4(0.0, 1.0, 0.0, 1.0)
- : vec4(1.0, 0.0, 0.0, 1.0);
- """
- def __init__(self, signature):
- self.__signature = signature
-
- def make_additional_declarations(self):
- return 'uniform {0} expected;\n'.format(self.__signature.rettype)
-
- def make_result_handler(self, invocation, output_var):
- statements = ' {0} result = {1};\n'.format(
- self.__signature.rettype, invocation)
- statements += ' {v} = {cond} ? {green} : {red};\n'.format(
- v=output_var, cond='result == expected',
- green='vec4(0.0, 1.0, 0.0, 1.0)',
- red='vec4(1.0, 0.0, 0.0, 1.0)')
- return statements
-
- def make_result_test(self, test_num, test_vector, draw):
- test = 'uniform {0} expected {1}\n'.format(
- shader_runner_type(self.__signature.rettype),
- shader_runner_format(
- generators.column_major_values(test_vector.result)))
- test += draw
- test += 'probe rgba {0} 0 0.0 1.0 0.0 1.0\n'.format(test_num)
- return test
-
-
-class FloatComparator(Comparator):
- """Comparator that tests functions returning floats or vecs using a
- strict equality test.
-
- This comparator causes code to be generated in the following form:
-
- rettype result = func(args);
- output_var = distance(result, expected) <= tolerance
- ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
- """
- def __init__(self, signature):
- self.__signature = signature
-
- def make_additional_declarations(self):
- decls = 'uniform double tolerance;\n'
- decls += 'uniform {0} expected;\n'.format(self.__signature.rettype)
- return decls
-
- def make_indexers(self):
- """Build a list of strings which index into every possible
- value of the result. For example, if the result is a vec2,
- then build the indexers ['[0]', '[1]'].
- """
- if self.__signature.rettype.num_cols == 1:
- col_indexers = ['']
- else:
- col_indexers = ['[{0}]'.format(i)
- for i in xrange(self.__signature.rettype.num_cols)]
- if self.__signature.rettype.num_rows == 1:
- row_indexers = ['']
- else:
- row_indexers = ['[{0}]'.format(i)
- for i in xrange(self.__signature.rettype.num_rows)]
- return [col_indexer + row_indexer
- for col_indexer in col_indexers
- for row_indexer in row_indexers]
-
- def make_result_handler(self, invocation, output_var):
- statements = ' {0} result = {1};\n'.format(
- self.__signature.rettype, invocation)
- # Can't use distance when testing itself, or when the rettype
- # is a matrix.
- if self.__signature.name == 'distance' or \
- self.__signature.rettype.is_matrix:
- statements += ' {0} residual = result - expected;\n'.format(
- self.__signature.rettype)
- statements += ' double error_sq = {0};\n'.format(
- ' + '.join(
- 'residual{0} * residual{0}'.format(indexer)
- for indexer in self.make_indexers()))
- condition = 'error_sq <= tolerance * tolerance'
- else:
- condition = 'distance(result, expected) <= tolerance'
- statements += ' {v} = {cond} ? {green} : {red};\n'.format(
- v=output_var, cond=condition, green='vec4(0.0, 1.0, 0.0, 1.0)',
- red='vec4(1.0, 0.0, 0.0, 1.0)')
- return statements
-
- def make_result_test(self, test_num, test_vector, draw):
- test = 'uniform {0} expected {1}\n'.format(
- shader_runner_type(self.__signature.rettype),
- shader_runner_format(
- generators.column_major_values(test_vector.result)))
- test += 'uniform double tolerance {0}\n'.format(
- shader_runner_format([test_vector.tolerance]))
- test += draw
- test += 'probe rgba {0} 0 0.0 1.0 0.0 1.0\n'.format(test_num)
- return test
-
-
-class ShaderTest(object):
- """Class used to build a test of a single built-in. This is an
- abstract base class--derived types should override test_prefix(),
- make_vertex_shader(), make_fragment_shader(), and other functions
- if necessary.
- """
- __metaclass__ = abc.ABCMeta
-
- def __init__(self, signature, test_vectors, use_if):
- """Prepare to build a test for a single built-in. signature
- is the signature of the built-in (a key from the
- builtin_function.test_suite dict), and test_vectors is the
- list of test vectors for testing the given builtin (the
- corresponding value from the builtin_function.test_suite
- dict).
-
- If use_if is True, then the generated test checks the result
- by using it in an if statement--this only works for builtins
- returning bool.
- """
- self._signature = signature
- self._test_vectors = test_vectors
- if use_if:
- self._comparator = BoolIfComparator(signature)
- elif signature.rettype.base_type == glsl_types.GLSL_BOOL:
- self._comparator = BoolComparator(signature)
- elif signature.rettype.base_type == glsl_types.GLSL_DOUBLE:
- self._comparator = FloatComparator(signature)
- else:
- raise Exception('Unexpected rettype {0}'.format(signature.rettype))
-
- def glsl_version(self):
- return self._signature.version_introduced
-
- def draw_command(self):
- if self.glsl_version() >= 140:
- return 'draw arrays GL_TRIANGLE_FAN 0 4\n'
- else:
- return 'draw rect -1 -1 2 2\n'
-
- def make_additional_requirements(self):
- """Return a string that should be included in the test's
- [require] section.
- """
- if self._signature.extension:
- return 'GL_{0}\n'.format(self._signature.extension)
- return ""
-
- @abc.abstractmethod
- def test_prefix(self):
- """Return the prefix that should be used in the test file name
- to identify the type of test, e.g. "vs" for a vertex shader
- test.
- """
-
- @abc.abstractmethod
- def make_vertex_shader(self):
- """Return the vertex shader for this test."""
-
- def make_geometry_shader(self):
- """Return the geometry shader for this test (or None if this
- test doesn't require a geometry shader). No need to
- reimplement this function in classes that don't use geometry
- shaders.
- """
- return None
-
- def make_geometry_layout(self):
- """Return the geometry layout for this test (or None if this
- test doesn't require a geometry layout section). No need to
- reimplement this function in classes that don't use geometry
- shaders.
- """
- return None
-
- @abc.abstractmethod
- def make_fragment_shader(self):
- """Return the fragment shader for this test."""
-
- def make_test_shader(self, additional_declarations, prefix_statements,
- output_var, suffix_statements):
- """Generate the shader code necessary to test the built-in.
- additional_declarations is a string containing any
- declarations that need to be before the main() function of the
- shader. prefix_statements is a string containing any
- additional statements than need to be inside the main()
- function of the shader, before the built-in function is
- called. output_var is the variable that the result of the
- built-in function should be assigned to, after conversion to a
- vec4. suffix_statements is a string containing any additional
- statements that need to be inside the main() funciton of the
- shader, after the built-in function is called.
- """
- shader = ''
- if self._signature.extension:
- shader += '#extension GL_{0} : require\n'.format(self._signature.extension)
- shader += additional_declarations
- for i in xrange(len(self._signature.argtypes)):
- shader += 'uniform {0} arg{1};\n'.format(
- self._signature.argtypes[i], i)
- shader += self._comparator.make_additional_declarations()
- shader += '\n'
- shader += 'void main()\n'
- shader += '{\n'
- shader += prefix_statements
- invocation = self._signature.template.format(
- *['arg{0}'.format(i)
- for i in xrange(len(self._signature.argtypes))])
- shader += self._comparator.make_result_handler(invocation, output_var)
- shader += suffix_statements
- shader += '}\n'
- return shader
-
- def make_test(self):
- """Make the complete shader_runner test file, and return it as
- a string.
- """
- test = ''
- for test_num, test_vector in enumerate(self._test_vectors):
- for i in xrange(len(test_vector.arguments)):
- test += 'uniform {0} arg{1} {2}\n'.format(
- shader_runner_type(self._signature.argtypes[i]),
- i, shader_runner_format(
- generators.column_major_values(test_vector.arguments[i])))
- # Note: shader_runner uses a 250x250 window so we must
- # ensure that test_num <= 250.
- test += self._comparator.make_result_test(
- test_num % 250, test_vector, self.draw_command())
- return test
-
- def make_vbo_data(self):
- # Starting with GLSL 1.40/GL 3.1, we need to use VBOs and
- # vertex shader input bindings for our vertex data instead of
- # the piglit drawing utilities and gl_Vertex.
- if self.glsl_version() < 140:
- return ""
- vbo = '[vertex data]\n'
- vbo += 'vertex/float/2\n'
- vbo += '-1.0 -1.0\n'
- vbo += ' 1.0 -1.0\n'
- vbo += ' 1.0 1.0\n'
- vbo += '-1.0 1.0\n'
- vbo += '\n'
- return vbo
-
- def filename(self):
- argtype_names = '-'.join(
- str(argtype) for argtype in self._signature.argtypes)
- if self._signature.extension:
- subdir = self._signature.extension.lower()
- else:
- subdir = 'glsl-{0:1.2f}'.format(float(self.glsl_version()) / 100)
- return os.path.join(
- 'spec', subdir, 'execution', 'built-in-functions',
- '{0}-{1}-{2}{3}.shader_test'.format(
- self.test_prefix(), self._signature.name, argtype_names,
- self._comparator.testname_suffix()))
-
- def generate_shader_test(self):
- """Generate the test and write it to the output file."""
- shader_test = '[require]\n'
- shader_test += 'GLSL >= {0:1.2f}\n'.format(
- float(self.glsl_version()) / 100)
- shader_test += self.make_additional_requirements()
- shader_test += '\n'
- shader_test += '[vertex shader]\n'
- shader_test += self.make_vertex_shader()
- shader_test += '\n'
- gs = self.make_geometry_shader()
- if gs:
- shader_test += '[geometry shader]\n'
- shader_test += gs
- shader_test += '\n'
- gl = self.make_geometry_layout()
- if gl:
- shader_test += '[geometry layout]\n'
- shader_test += gl
- shader_test += '\n'
- shader_test += '[fragment shader]\n'
- shader_test += self.make_fragment_shader()
- shader_test += '\n'
- shader_test += self.make_vbo_data()
- shader_test += '[test]\n'
- shader_test += self.make_test()
- filename = self.filename()
- dirname = os.path.dirname(filename)
- if not os.path.exists(dirname):
- os.makedirs(dirname)
- with open(filename, 'w') as f:
- f.write(shader_test)
-
-
-class VertexShaderTest(ShaderTest):
- """Derived class for tests that exercise the built-in in a vertex
- shader.
- """
- def test_prefix(self):
- return 'vs'
-
- def make_vertex_shader(self):
- if self.glsl_version() >= 140:
- return self.make_test_shader(
- 'in vec4 vertex;\n' +
- 'out vec4 color;\n',
- ' gl_Position = vertex;\n',
- 'color', '')
- else:
- return self.make_test_shader(
- 'varying vec4 color;\n',
- ' gl_Position = gl_Vertex;\n',
- 'color', '')
-
- def make_fragment_shader(self):
- shader = '''varying vec4 color;
-
-void main()
-{
- gl_FragColor = color;
-}
-'''
- return shader
-
-
-class GeometryShaderTest(ShaderTest):
- """Derived class for tests that exercise the built-in in a
- geometry shader.
- """
- def test_prefix(self):
- return 'gs'
-
- def glsl_version(self):
- return max(150, ShaderTest.glsl_version(self))
-
- def make_vertex_shader(self):
- shader = ''
- shader += "in vec4 vertex;\n"
- shader += "out vec4 vertex_to_gs;\n"
-
- shader += "void main()\n"
- shader += "{\n"
- shader += " vertex_to_gs = vertex;\n"
- shader += "}\n"
-
- return shader
-
- def make_geometry_shader(self):
- additional_declarations = ''
- additional_declarations += 'layout(triangles) in;\n'
- additional_declarations \
- += 'layout(triangle_strip, max_vertices = 3) out;\n'
- additional_declarations += 'in vec4 vertex_to_gs[3];\n'
- additional_declarations += 'out vec4 color;\n'
- return self.make_test_shader(
- additional_declarations,
- ' vec4 tmp_color;\n',
- 'tmp_color',
- ' for (int i = 0; i < 3; i++) {\n'
- ' gl_Position = vertex_to_gs[i];\n'
- ' color = tmp_color;\n'
- ' EmitVertex();\n'
- ' }\n')
-
- def make_fragment_shader(self):
- shader = '''varying vec4 color;
-
-void main()
-{
- gl_FragColor = color;
-}
-'''
- return shader
-
-
-class FragmentShaderTest(ShaderTest):
- """Derived class for tests that exercise the built-in in a
- fragment shader.
- """
- def test_prefix(self):
- return 'fs'
-
- def make_vertex_shader(self):
- shader = ""
- if self.glsl_version() >= 140:
- shader += "in vec4 vertex;\n"
-
- shader += "void main()\n"
- shader += "{\n"
- if self.glsl_version() >= 140:
- shader += " gl_Position = vertex;\n"
- else:
- shader += " gl_Position = gl_Vertex;\n"
- shader += "}\n"
-
- return shader
-
- def make_fragment_shader(self):
- return self.make_test_shader('', '', 'gl_FragColor', '')
-
-
-def all_tests():
- for use_if in [False, True]:
- for signature, vectors in builtin_function_fp64.test_suite.iteritems():
- if use_if and signature.rettype != glsl_types.GLSL_BOOL:
- continue
- yield VertexShaderTest(signature, vectors, use_if)
- yield GeometryShaderTest(signature, vectors, use_if)
- yield FragmentShaderTest(signature, vectors, use_if)
-
-
-def main():
- desc = 'Generate shader tests that test built-in functions using uniforms'
- usage = 'usage: %prog [-h] [--names-only]'
- parser = optparse.OptionParser(description=desc, usage=usage)
- parser.add_option(
- '--names-only',
- dest='names_only',
- action='store_true',
- help="Don't output files, just generate a list of filenames to stdout")
- options, args = parser.parse_args()
- for test in all_tests():
- if not options.names_only:
- test.generate_shader_test()
- print test.filename()
-
-
-if __name__ == '__main__':
- main()
diff --git a/generated_tests/templates/gen_builtin_uniform_tests/cs.shader_test.mako b/generated_tests/templates/gen_builtin_uniform_tests/cs.shader_test.mako
index 60b4df1..5667130 100644
--- a/generated_tests/templates/gen_builtin_uniform_tests/cs.shader_test.mako
+++ b/generated_tests/templates/gen_builtin_uniform_tests/cs.shader_test.mako
@@ -24,6 +24,9 @@
[require]
GLSL >= ${'{:1.2f}'.format(float(glsl_version) / 100)}
+% if signature.extension:
+GL_${signature.extension}
+% endif
[compute shader]
% if signature.extension:
diff --git a/generated_tests/templates/gen_builtin_uniform_tests/fs.shader_test.mako b/generated_tests/templates/gen_builtin_uniform_tests/fs.shader_test.mako
index 75935f1..5eda73f 100644
--- a/generated_tests/templates/gen_builtin_uniform_tests/fs.shader_test.mako
+++ b/generated_tests/templates/gen_builtin_uniform_tests/fs.shader_test.mako
@@ -24,6 +24,9 @@
[require]
GLSL >= ${'{:1.2f}'.format(float(glsl_version) / 100)}
+% if signature.extension:
+GL_${signature.extension}
+% endif
[vertex shader]
% if glsl_version >= 140:
diff --git a/generated_tests/templates/gen_builtin_uniform_tests/gs.shader_test.mako b/generated_tests/templates/gen_builtin_uniform_tests/gs.shader_test.mako
index 81ed1b8..a0bd039 100644
--- a/generated_tests/templates/gen_builtin_uniform_tests/gs.shader_test.mako
+++ b/generated_tests/templates/gen_builtin_uniform_tests/gs.shader_test.mako
@@ -24,6 +24,9 @@
[require]
GLSL >= ${'{:1.2f}'.format(float(glsl_version) / 100)}
+% if signature.extension:
+GL_${signature.extension}
+% endif
[vertex shader]
in vec4 vertex;
diff --git a/generated_tests/templates/gen_builtin_uniform_tests/utils.mako b/generated_tests/templates/gen_builtin_uniform_tests/utils.mako
index 742a703..3fe7bcb 100644
--- a/generated_tests/templates/gen_builtin_uniform_tests/utils.mako
+++ b/generated_tests/templates/gen_builtin_uniform_tests/utils.mako
@@ -95,7 +95,7 @@
${test_bool(n, vector, draw, signature)}
% elif comparator == 'int':
${test_int(n, vector, draw, signature)}
- % elif comparator == 'float':
+ % elif comparator in ['float', 'double']:
${test_float(n, vector, draw, signature)}
% endif
% endfor
@@ -119,7 +119,7 @@
<%def name="test_float(test_num, vector, draw, signature)" filter='trim'>
uniform ${signature.rettype.as_shader_runner_uniform} expected ${shader_runner_format(column_major_values(vector.result))}
- uniform float tolerance ${shader_runner_format([vector.tolerance])}
+ uniform ${signature.rettype.base_type.name} tolerance ${shader_runner_format([vector.tolerance])}
${draw}
probe rgba ${test_num % 250} 0 0.0 1.0 0.0 1.0
</%def>
@@ -142,8 +142,8 @@
% if comparator == 'int':
uniform ${signature.rettype} expected;
- % elif comparator == 'float':
- uniform float tolerance;
+ % elif comparator in ['float', 'double']:
+ uniform ${comparator} tolerance;
uniform ${signature.rettype} expected;
% endif
@@ -158,7 +158,7 @@
${result_bool(output, signature)}
% elif comparator == 'int':
${result_int(output, signature)}
- % elif comparator == 'float':
+ % elif comparator in ['float', 'double']:
${result_float(output, signature)}
% endif
% for line in suffix:
@@ -192,7 +192,7 @@
${signature.rettype} result = ${invocation(signature)};
% if signature.name == 'distance' or signature.rettype.is_matrix:
${signature.rettype} residual = result - expected;
- float error_sq = ${' + '.join('residual{0} * residual{0}'.format(i) for i in make_indexer(signature))};
+ ${signature.rettype.base_type.name} error_sq = ${' + '.join('residual{0} * residual{0}'.format(i) for i in make_indexer(signature))};
${output} = error_sq <= tolerance * tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
% else:
${output} = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
diff --git a/generated_tests/templates/gen_builtin_uniform_tests/vs.shader_test.mako b/generated_tests/templates/gen_builtin_uniform_tests/vs.shader_test.mako
index c03cd06..1377d8e 100644
--- a/generated_tests/templates/gen_builtin_uniform_tests/vs.shader_test.mako
+++ b/generated_tests/templates/gen_builtin_uniform_tests/vs.shader_test.mako
@@ -24,6 +24,9 @@
[require]
GLSL >= ${'{:1.2f}'.format(float(glsl_version) / 100)}
+% if signature.extension:
+GL_${signature.extension}
+% endif
[vertex shader]
% if signature.extension:
--
2.2.0
More information about the Piglit
mailing list