[Piglit] [PATCH 20/26] gen_builtin_packing_tests.py PEP8 compliance
Dylan Baker
baker.dylan.c at gmail.com
Wed Jul 10 15:19:11 PDT 2013
A few errors according to the pep8 tool were left behind.
1255-1257: I believe these to be false positives, my reading of PEP 8
makes them seem correct, and the tool does not complain about
other similar lines
247, 392: These are part of a mako template that is embedded in the
python file. A better solution than wrapping them would be to
split them out of the python and put them in their own mako
files.
---
generated_tests/gen_builtin_packing_tests.py | 311 ++++++++++++++-------------
1 file changed, 161 insertions(+), 150 deletions(-)
diff --git a/generated_tests/gen_builtin_packing_tests.py b/generated_tests/gen_builtin_packing_tests.py
index 5eeea62..c614e10 100644
--- a/generated_tests/gen_builtin_packing_tests.py
+++ b/generated_tests/gen_builtin_packing_tests.py
@@ -280,7 +280,8 @@ vs_unpack_template = Template(dedent("""\
% if func.exact:
uniform int exact 1
% else:
- uniform int exact ${int(int(io.input[:-1]) in (0x0, 0xffffffff, 0x80808080, 0x81818181))}
+ uniform int exact ${int(int(io.input[:-1]) in (0x0, 0xffffffff, 0x80808080,
+ 0x81818181))}
% endif
% for j in range(func.num_valid_outputs):
uniform ${func.vector_type} expect${j} ${" ".join(io.valid_outputs[j])}
@@ -415,7 +416,8 @@ fs_unpack_template = Template(dedent("""\
% if func.exact:
uniform int exact 1
% else:
- uniform int exact ${int(int(io.input[:-1]) in (0x0, 0xffffffff, 0x80808080, 0x81818181))}
+ uniform int exact ${int(int(io.input[:-1]) in (0x0, 0xffffffff, 0x80808080,
+ 0x81818181))}
% endif
% for i in range(func.num_valid_outputs):
uniform ${func.vector_type} expect${i} ${" ".join(io.valid_outputs[i])}
@@ -427,24 +429,24 @@ fs_unpack_template = Template(dedent("""\
"""))
template_table = {
- ("const", "p", "2x16") : const_pack_template,
- ("const", "p", "4x8") : const_pack_template,
- ("const", "u", "2x16") : const_unpack_template,
- ("const", "u", "4x8") : const_unpack_template,
- ("vs", "p", "2x16") : vs_pack_template,
- ("vs", "p", "4x8") : vs_pack_template,
- ("vs", "u", "2x16") : vs_unpack_template,
- ("vs", "u", "4x8") : vs_unpack_template,
- ("fs", "p", "2x16") : fs_pack_template,
- ("fs", "p", "4x8") : fs_pack_template,
- ("fs", "u", "2x16") : fs_unpack_template,
- ("fs", "u", "4x8") : fs_unpack_template,
-}
+ ("const", "p", "2x16"): const_pack_template,
+ ("const", "p", "4x8"): const_pack_template,
+ ("const", "u", "2x16"): const_unpack_template,
+ ("const", "u", "4x8"): const_unpack_template,
+ ("vs", "p", "2x16"): vs_pack_template,
+ ("vs", "p", "4x8"): vs_pack_template,
+ ("vs", "u", "2x16"): vs_unpack_template,
+ ("vs", "u", "4x8"): vs_unpack_template,
+ ("fs", "p", "2x16"): fs_pack_template,
+ ("fs", "p", "4x8"): fs_pack_template,
+ ("fs", "u", "2x16"): fs_unpack_template,
+ ("fs", "u", "4x8"): fs_unpack_template}
# ----------------------------------------------------------------------------
# Math for pack/unpack functions
# ----------------------------------------------------------------------------
+
class FuncOpts:
"""Options that modify the evaluation of the GLSL pack/unpack functions.
@@ -492,6 +494,7 @@ class FuncOpts:
x = float32(x)
return self.__round_func(x)
+
def clamp(x, min, max):
if x < min:
return min
@@ -500,6 +503,7 @@ def clamp(x, min, max):
else:
return x
+
def round_to_nearest(x):
# Get fractional and integral parts.
(f, i) = modf(x)
@@ -509,6 +513,7 @@ def round_to_nearest(x):
else:
return i + copysign(1.0, x)
+
def round_to_even(x):
# Get fractional and integral parts.
(f, i) = modf(x)
@@ -520,6 +525,7 @@ def round_to_even(x):
else:
return i + copysign(1.0, x)
+
def pack_2x16(pack_1x16_func, x, y, func_opts):
"""Evaluate a GLSL pack2x16 function.
@@ -539,6 +545,7 @@ def pack_2x16(pack_1x16_func, x, y, func_opts):
return uint32((uy << 16) | ux)
+
def pack_4x8(pack_1x8_func, x, y, z, w, func_opts):
"""Evaluate a GLSL pack4x8 function.
@@ -564,6 +571,7 @@ def pack_4x8(pack_1x8_func, x, y, z, w, func_opts):
return uint32((uw << 24) | (uz << 16) | (uy << 8) | ux)
+
def unpack_2x16(unpack_1x16_func, u, func_opts):
"""Evaluate a GLSL unpack2x16 function.
@@ -585,6 +593,7 @@ def unpack_2x16(unpack_1x16_func, u, func_opts):
return (x, y)
+
def unpack_4x8(unpack_1x8_func, u, func_opts):
"""Evaluate a GLSL unpack4x8 function.
@@ -612,46 +621,55 @@ def unpack_4x8(unpack_1x8_func, u, func_opts):
return (x, y, z, w)
+
def pack_snorm_1x8(f32, func_opts):
"""Component-wise function of packSnorm4x8."""
assert(isinstance(f32, float32))
return uint8(int8(func_opts.round(clamp(f32, -1.0, +1.0) * 127.0)))
+
def pack_snorm_1x16(f32, func_opts):
"""Component-wise function of packSnorm2x16."""
assert(isinstance(f32, float32))
return uint16(int16(func_opts.round(clamp(f32, -1.0, +1.0) * 32767.0)))
+
def unpack_snorm_1x8(u8):
"""Component-wise function of unpackSnorm4x8."""
assert(isinstance(u8, uint8))
return float32(clamp(int8(u8) / 127.0, -1.0, +1.0))
+
def unpack_snorm_1x16(u16):
"""Component-wise function of unpackSnorm2x16."""
assert(isinstance(u16, uint16))
return float32(clamp(int16(u16) / 32767.0, -1.0, +1.0))
+
def pack_unorm_1x8(f32, func_opts):
"""Component-wise function of packUnorm4x8."""
assert(isinstance(f32, float32))
return uint8(func_opts.round(clamp(f32, 0.0, 1.0) * 255.0))
+
def pack_unorm_1x16(f32, func_opts):
"""Component-wise function of packUnorm2x16."""
assert(isinstance(f32, float32))
return uint16(func_opts.round(clamp(f32, 0.0, 1.0) * 65535.0))
+
def unpack_unorm_1x8(u8):
"""Component-wise function of unpackUnorm4x8."""
assert(isinstance(u8, uint8))
return float32(u8 / 255.0)
+
def unpack_unorm_1x16(u16):
"""Component-wise function of unpackUnorm2x16."""
assert(isinstance(u16, uint16))
return float32(u16 / 65535.0)
+
def pack_half_1x16(f32, func_opts):
"""Component-wise function of packHalf2x16."""
assert(isinstance(f32, float32))
@@ -664,11 +682,11 @@ def pack_half_1x16(f32, func_opts):
#
# The sign, exponent, and mantissa determine its value by:
#
- # if e = 0 and m = 0, then zero: (-1)^s * 0
- # if e = 0 and m != 0, then subnormal: (-1)^s * 2^(e - 14) * m / 2^10
- # if 0 < e < 31, then normal: (-1)^s * 2^(e - 15) * (1 + m / 2^10)
- # if e = 31 and m = 0, then inf: (-1)^s * inf
- # if e = 31 and m != 0, then nan
+ # if e = 0 and m = 0, then zero: (-1)^s * 0
+ # if e = 0 and m != 0, then subnormal: (-1)^s * 2^(e - 14) * m / 2^10
+ # if 0 < e < 31, then normal: (-1)^s * 2^(e - 15) * (1 + m / 2^10)
+ # if e = 31 and m = 0, then inf: (-1)^s * inf
+ # if e = 31 and m != 0, then nan
#
# where 0 <= m < 2^10.
#
@@ -697,7 +715,7 @@ def pack_half_1x16(f32, func_opts):
# Calculate sign bit.
# Use copysign() to handle the case where x is -0.0.
if copysign(1.0, f32) < 0.0:
- s = 1
+ s = 1
# To reduce the number of cases in the if-tree below, decompose `abs(f32)`
# rather than `f32`.
@@ -755,6 +773,7 @@ def pack_half_1x16(f32, func_opts):
return uint16((s << 15) | (e << 10) | m)
+
def unpack_half_1x16(u16):
"""Component-wise function of unpackHalf2x16."""
assert(isinstance(u16, uint16))
@@ -767,11 +786,11 @@ def unpack_half_1x16(u16):
#
# The sign, exponent, and mantissa determine its value by:
#
- # if e = 0 and m = 0, then zero: (-1)^s * 0
- # if e = 0 and m != 0, then subnormal: (-1)^s * 2^(e - 14) * m / 2^10
- # if 0 < e < 31, then normal: (-1)^s * 2^(e - 15) * (1 + m / 2^10)
- # if e = 31 and m = 0, then inf: (-1)^s * inf
- # if e = 31 and m != 0, then nan
+ # if e = 0 and m = 0, then zero: (-1)^s * 0
+ # if e = 0 and m != 0, then subnormal: (-1)^s * 2^(e - 14) * m / 2^10
+ # if 0 < e < 31, then normal: (-1)^s * 2^(e - 15) * (1 + m / 2^10)
+ # if e = 31 and m = 0, then inf: (-1)^s * inf
+ # if e = 31 and m != 0, then nan
#
# where 0 <= m < 2^10.
@@ -787,7 +806,7 @@ def unpack_half_1x16(u16):
if e == 0:
return float32(sign * 2.0**(-14) * (m / 2.0**10))
elif 1 <= e and e <= 30:
- return float32(sign * 2.0**(e - 15.0) * (1.0 + m / 2.0**10))
+ return float32(sign * 2.0**(e - 15.0) * (1.0 + m / 2.0**10))
elif e == 31 and m == 0:
return float32(sign * float32("inf"))
elif e == 31 and m != 0:
@@ -817,17 +836,16 @@ full_input_table = dict()
#
reduced_input_table = dict()
+
def make_inputs_for_pack_snorm_2x16():
# The domain of packSnorm2x16 is [-inf, +inf]^2. The function clamps
# its input into the range [-1, +1]^2.
- pos = (
- 0.0, # zero
- 0.1, # near zero
- 0.9, # slightly below the clamp boundary
- 1.0, # the clamp boundary
- 1.1, # slightly above the clamp boundary
- float("+inf"),
- )
+ pos = (0.0, # zero
+ 0.1, # near zero
+ 0.9, # slightly below the clamp boundary
+ 1.0, # the clamp boundary
+ 1.1, # slightly above the clamp boundary
+ float("+inf"))
neg = tuple(reversed(tuple(-x for x in pos)))
return tuple(float32(x) for x in pos + neg)
@@ -842,8 +860,7 @@ full_input_table["unpackSnorm2x16"] = tuple(uint16(u) for u in (
2**15 - 1,
2**15,
2**15 + 1,
- 2**16 - 1, # max uint16
- ))
+ 2**16 - 1)) # max uint16
# XXX: Perhaps there is a better choice of test inputs?
full_input_table["unpackSnorm4x8"] = tuple(uint8(u) for u in (
@@ -851,23 +868,21 @@ full_input_table["unpackSnorm4x8"] = tuple(uint8(u) for u in (
2**7 - 1,
2**7,
2**7 + 1,
- 2**8 - 1, # max uint8
- ))
+ 2**8 - 1)) # max uint8
full_input_table["packUnorm2x16"] = tuple(float32(x) for x in (
# The domain of packUnorm2x16 is [-inf, +inf]^2. The function clamps its
# input into the range [0, 1]^2.
"-inf",
- -0.1, # slightly below the inner clamp boundary
- -0.0, # infintesimally below the inner clamp boundary
- +0.0, # the inner clamp boundary
- +0.1, # slightly above the inner clamp boundary
- +0.9, # slightly below the outer clamp boundary
- +1.0, # the outer clamp boundary
- +1.1, # slightly above the outer clamp boundary
- "+inf",
- ))
+ -0.1, # slightly below the inner clamp boundary
+ -0.0, # infintesimally below the inner clamp boundary
+ +0.0, # the inner clamp boundary
+ +0.1, # slightly above the inner clamp boundary
+ +0.9, # slightly below the outer clamp boundary
+ +1.0, # the outer clamp boundary
+ +1.1, # slightly above the outer clamp boundary
+ "+inf"))
reduced_input_table["packUnorm2x16"] = None
@@ -877,6 +892,7 @@ full_input_table["packUnorm4x8"] = full_input_table["packUnorm2x16"]
full_input_table["unpackUnorm2x16"] = full_input_table["unpackSnorm2x16"]
full_input_table["unpackUnorm4x8"] = full_input_table["unpackSnorm4x8"]
+
def make_inputs_for_pack_half_2x16():
# The domain of packHalf2x16 is ([-inf, +inf] + {NaN})^2. The function
# does not clamp its input.
@@ -886,14 +902,13 @@ def make_inputs_for_pack_half_2x16():
subnormal_min = 2.0**(-14) * (1.0 / 2.0**10)
subnormal_max = 2.0**(-14) * (1023.0 / 2.0**10)
- normal_min = 2.0**(-14) * (1.0 + 0.0 / 2.0**10)
- normal_max = 2.0**15 * (1.0 + 1023.0 / 2.0**10)
- min_step = 2.0**(-24)
- max_step = 2.0**5
+ normal_min = 2.0**(-14) * (1.0 + 0.0 / 2.0**10)
+ normal_max = 2.0**15 * (1.0 + 1023.0 / 2.0**10)
+ min_step = 2.0**(-24)
+ max_step = 2.0**5
pos = tuple(float32(x) for x in (
# Inputs that result in 0.0 .
- #
0.0,
0.0 + 0.25 * min_step,
@@ -906,7 +921,8 @@ def make_inputs_for_pack_half_2x16():
#
0.0 + 0.50 * min_step,
- # Inputs that result in a subnormal float16.
+ # Inputs that result in a subnormal
+ # float16.
#
0.0 + 0.75 * min_step,
subnormal_min + 0.00 * min_step,
@@ -966,46 +982,37 @@ def make_inputs_for_pack_half_2x16():
normal_max + 1.00 * max_step,
normal_max + 2.00 * max_step,
- "+inf",
- ))
+ "+inf"))
neg = tuple(reversed([-x for x in pos]))
return neg + pos
full_input_table["packHalf2x16"] = make_inputs_for_pack_half_2x16()
-reduced_input_table["packHalf2x16"] = tuple(float32(x) for x in (
- "-inf",
- -2.0,
- -1.0,
- -0.0,
- +0.0,
- +1.0,
- +2.0,
- "+inf",
- ))
+reduced_input_table["packHalf2x16"] = tuple(float32(x) for x in ("-inf",
+ -2.0,
+ -1.0,
+ -0.0,
+ +0.0,
+ +1.0,
+ +2.0,
+ "+inf"))
+
def make_inputs_for_unpack_half_2x16():
# For each of the two classes of float16 values, subnormal and normalized,
# below are listed the exponent and mantissa of the class's boundary
# values and some values slightly inside the bounds.
- bounds = (
- ( 0, 0), # zero
-
- ( 0, 1), # subnormal_min
- ( 0, 2), # subnormal_min + min_step
-
- ( 0, 1022), # subnormal_max - min_step
- ( 0, 1023), # subnormal_max
-
- ( 1, 0), # normal_min
- ( 1, 1), # normal_min + min_step
-
- (30, 1022), # normal_max - max_step
- (30, 1023), # normal_max
-
- (31, 0), # inf
- )
+ bounds = ((0, 0), # zero
+ (0, 1), # subnormal_min
+ (0, 2), # subnormal_min + min_step
+ (0, 1022), # subnormal_max - min_step
+ (0, 1023), # subnormal_max
+ (1, 0), # normal_min
+ (1, 1), # normal_min + min_step
+ (30, 1022), # normal_max - max_step
+ (30, 1023), # normal_max
+ (31, 0)) # inf
def make_uint16(s, e, m):
return uint16((s << 15) | (e << 10) | m)
@@ -1036,6 +1043,7 @@ full_input_table["unpackHalf2x16"] = make_inputs_for_unpack_half_2x16()
#
InOutTuple = namedtuple("InOutTuple", ("input", "valid_outputs"))
+
def glsl_literal(x):
"""Convert the given number to a string that represents a GLSL literal.
@@ -1070,6 +1078,7 @@ def glsl_literal(x):
else:
assert(False)
+
def make_inouts_for_pack_2x16(pack_1x16_func,
all_float32_inputs,
reduced_inputs=None):
@@ -1117,6 +1126,7 @@ def make_inouts_for_pack_2x16(pack_1x16_func,
return inout_seq
+
def make_inouts_for_pack_4x8(pack_1x8_func, float32_inputs):
"""Determine valid outputs for a given GLSL pack4x8 function.
@@ -1154,6 +1164,7 @@ def make_inouts_for_pack_4x8(pack_1x8_func, float32_inputs):
valid_outputs=valid_outputs_1))
return inout_seq
+
def make_inouts_for_unpack_2x16(unpack_1x16_func, uint16_inputs):
"""Determine expected outputs of a given GLSL unpack2x16 function.
@@ -1179,6 +1190,7 @@ def make_inouts_for_unpack_2x16(unpack_1x16_func, uint16_inputs):
return inout_seq
+
def make_inouts_for_unpack_4x8(unpack_1x8_func, uint8_inputs):
"""Determine expected outputs of a given GLSL unpack4x8 function.
@@ -1218,51 +1230,58 @@ def make_inouts_for_unpack_4x8(unpack_1x8_func, uint8_inputs):
glsl_literal(vec4_1[2]),
glsl_literal(vec4_1[3])))
- inout_seq.append(
- InOutTuple(input=glsl_literal(u32_0),
- valid_outputs=valid_outputs_0))
- inout_seq.append(
- InOutTuple(input=glsl_literal(u32_1),
- valid_outputs=valid_outputs_1))
+ inout_seq.append(InOutTuple(input=glsl_literal(u32_0),
+ valid_outputs=valid_outputs_0))
+ inout_seq.append(InOutTuple(input=glsl_literal(u32_1),
+ valid_outputs=valid_outputs_1))
return inout_seq
# This table maps GLSL pack/unpack function names to the precision of their
# return type.
-result_precision_table = {
- "packSnorm2x16": "highp",
- "packSnorm4x8": "highp",
- "packUnorm2x16": "highp",
- "packUnorm4x8": "highp",
- "packHalf2x16": "highp",
-
- "unpackSnorm2x16": "highp",
- "unpackSnorm4x8": "highp",
- "unpackUnorm2x16": "highp",
- "unpackUnorm4x8": "highp",
- "unpackHalf2x16": "mediump",
- }
+result_precision_table = {"packSnorm2x16": "highp",
+ "packSnorm4x8": "highp",
+ "packUnorm2x16": "highp",
+ "packUnorm4x8": "highp",
+ "packHalf2x16": "highp",
+ "unpackSnorm2x16": "highp",
+ "unpackSnorm4x8": "highp",
+ "unpackUnorm2x16": "highp",
+ "unpackUnorm4x8": "highp",
+ "unpackHalf2x16": "mediump"}
# This table maps GLSL pack/unpack function names to a sequence of InOutTuple.
-inout_table = {
- "packSnorm2x16": make_inouts_for_pack_2x16(pack_snorm_1x16, full_input_table["packSnorm2x16"], reduced_input_table["packSnorm2x16"]),
- "packSnorm4x8": make_inouts_for_pack_4x8(pack_snorm_1x8, full_input_table["packSnorm4x8"]),
- "packUnorm2x16": make_inouts_for_pack_2x16(pack_unorm_1x16, full_input_table["packUnorm2x16"], reduced_input_table["packUnorm2x16"]),
- "packUnorm4x8": make_inouts_for_pack_4x8(pack_unorm_1x8, full_input_table["packUnorm4x8"]),
- "packHalf2x16": make_inouts_for_pack_2x16(pack_half_1x16, full_input_table["packHalf2x16"], reduced_input_table["packHalf2x16"]),
-
-
- "unpackSnorm2x16": make_inouts_for_unpack_2x16(unpack_snorm_1x16, full_input_table["unpackSnorm2x16"]),
- "unpackSnorm4x8": make_inouts_for_unpack_4x8(unpack_snorm_1x8, full_input_table["unpackSnorm4x8"]),
- "unpackUnorm2x16": make_inouts_for_unpack_2x16(unpack_unorm_1x16, full_input_table["unpackUnorm2x16"]),
- "unpackUnorm4x8": make_inouts_for_unpack_4x8(unpack_unorm_1x8, full_input_table["unpackUnorm4x8"]),
- "unpackHalf2x16": make_inouts_for_unpack_2x16(unpack_half_1x16, full_input_table["unpackHalf2x16"]),
- }
+inout_table = {"packSnorm2x16": make_inouts_for_pack_2x16(
+ pack_snorm_1x16,
+ full_input_table["packSnorm2x16"],
+ reduced_input_table["packSnorm2x16"]),
+ "packSnorm4x8": make_inouts_for_pack_4x8(
+ pack_snorm_1x8, full_input_table["packSnorm4x8"]),
+ "packUnorm2x16": make_inouts_for_pack_2x16(
+ pack_unorm_1x16, full_input_table["packUnorm2x16"],
+ reduced_input_table["packUnorm2x16"]),
+ "packUnorm4x8": make_inouts_for_pack_4x8(
+ pack_unorm_1x8, full_input_table["packUnorm4x8"]),
+ "packHalf2x16": make_inouts_for_pack_2x16(
+ pack_half_1x16, full_input_table["packHalf2x16"],
+ reduced_input_table["packHalf2x16"]),
+ "unpackSnorm2x16": make_inouts_for_unpack_2x16(
+ unpack_snorm_1x16, full_input_table["unpackSnorm2x16"]),
+ "unpackSnorm4x8": make_inouts_for_unpack_4x8(
+ unpack_snorm_1x8, full_input_table["unpackSnorm4x8"]),
+ "unpackUnorm2x16": make_inouts_for_unpack_2x16(
+ unpack_unorm_1x16, full_input_table["unpackUnorm2x16"]),
+ "unpackUnorm4x8": make_inouts_for_unpack_4x8(
+ unpack_unorm_1x8, full_input_table["unpackUnorm4x8"]),
+ "unpackHalf2x16": make_inouts_for_unpack_2x16(
+ unpack_half_1x16, full_input_table["unpackHalf2x16"])}
+
# ----------------------------------------------------------------------------
# Generate test files
# ----------------------------------------------------------------------------
+
class FuncInfo:
"""Information for a GLSL pack/unpack function.
@@ -1304,11 +1323,12 @@ class FuncInfo:
self.dimension = "2x16"
self.vector_type = "vec2"
elif name.endswith("4x8"):
- self.dimension = "4x8"
+ self.dimension = "4x8"
self.vector_type = "vec4"
else:
assert(False)
+
class ShaderTest:
"""A .shader_test file."""
@@ -1321,30 +1341,21 @@ class ShaderTest:
FuncInfo("packUnorm2x16", requirements),
FuncInfo("packUnorm4x8", requirements),
FuncInfo("packHalf2x16", requirements),
-
FuncInfo("unpackSnorm2x16", requirements),
FuncInfo("unpackSnorm4x8", requirements),
FuncInfo("unpackUnorm2x16", requirements),
FuncInfo("unpackUnorm4x8", requirements),
- FuncInfo("unpackHalf2x16", requirements),
- )
+ FuncInfo("unpackHalf2x16", requirements))
requirements = "GL ES >= 3.0\nGLSL ES >= 3.00"
- glsl_es_300_funcs = (
- FuncInfo("packSnorm2x16", requirements),
- FuncInfo("packUnorm2x16", requirements),
- FuncInfo("packHalf2x16", requirements),
-
- FuncInfo("unpackSnorm2x16", requirements),
- FuncInfo("unpackUnorm2x16", requirements),
- FuncInfo("unpackHalf2x16", requirements),
- )
+ glsl_es_300_funcs = (FuncInfo("packSnorm2x16", requirements),
+ FuncInfo("packUnorm2x16", requirements),
+ FuncInfo("packHalf2x16", requirements),
+ FuncInfo("unpackSnorm2x16", requirements),
+ FuncInfo("unpackUnorm2x16", requirements),
+ FuncInfo("unpackHalf2x16", requirements))
- execution_stages = (
- "const",
- "vs",
- "fs",
- )
+ execution_stages = ("const", "vs", "fs")
for s in execution_stages:
for f in glsl_es_300_funcs:
@@ -1361,13 +1372,12 @@ class ShaderTest:
func_info.name[0],
func_info.dimension)]
self.__func_info = func_info
- self.__filename = os.path.join(
- "spec",
- api,
- "execution",
- "built-in-functions",
- "{0}-{1}.shader_test"\
- .format(execution_stage, func_info.name))
+ self.__filename = os.path.join("spec",
+ api,
+ "execution",
+ "built-in-functions",
+ "{0}-{1}.shader_test".format(
+ execution_stage, func_info.name))
@property
def filename(self):
@@ -1382,16 +1392,17 @@ class ShaderTest:
ctx = mako.runtime.Context(buffer, func=self.__func_info)
self.__template.render_context(ctx)
+
def main():
- parser = optparse.OptionParser(
- description="Generate shader tests that test the built-in " + \
- "packing functions",
- usage="usage: %prog [-h] [--names-only]")
- parser.add_option(
- '--names-only',
- dest='names_only',
- action='store_true',
- help="Don't output files, just generate a list of filenames to stdout")
+ parser = optparse.OptionParser(description="Generate shader tests that "
+ "test the built-inpacking "
+ "functions",
+ usage="usage: %prog [-h] [--names-only]")
+ 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()
--
1.8.3.1
More information about the Piglit
mailing list