1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief GLES3 shader constant expression tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fShaderConstExprTests.hpp"
25
26 #include "glsShaderLibrary.hpp"
27 #include "glsShaderConstExprTests.hpp"
28
29 #include "tcuStringTemplate.hpp"
30 #include "gluShaderUtil.hpp"
31
32 #include "deStringUtil.hpp"
33 #include "deMath.h"
34
35 namespace deqp
36 {
37 namespace gles3
38 {
39 namespace Functional
40 {
41
42 // builtins
43 class ShaderConstExprBuiltinTests : public TestCaseGroup
44 {
45 public:
ShaderConstExprBuiltinTests(Context & context)46 ShaderConstExprBuiltinTests(Context &context) : TestCaseGroup(context, "builtin_functions", "Builtin functions")
47 {
48 }
~ShaderConstExprBuiltinTests(void)49 virtual ~ShaderConstExprBuiltinTests(void)
50 {
51 }
52
53 void init(void);
54
55 void addChildGroup(const char *name, const char *desc, const gls::ShaderConstExpr::TestParams *cases, int numCases);
56 };
57
addChildGroup(const char * name,const char * desc,const gls::ShaderConstExpr::TestParams * cases,int numCases)58 void ShaderConstExprBuiltinTests::addChildGroup(const char *name, const char *desc,
59 const gls::ShaderConstExpr::TestParams *cases, int numCases)
60 {
61 const std::vector<tcu::TestNode *> children = createTests(
62 m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), cases, numCases, glu::GLSL_VERSION_300_ES);
63 tcu::TestCaseGroup *group = new tcu::TestCaseGroup(m_testCtx, name, desc);
64
65 addChild(group);
66
67 for (int i = 0; i < (int)children.size(); i++)
68 group->addChild(children[i]);
69 }
70
init(void)71 void ShaderConstExprBuiltinTests::init(void)
72 {
73 using namespace gls::ShaderConstExpr;
74
75 // ${T} => final type, ${MT} => final type but with scalar version usable even when T is a vector
76
77 // Trigonometry
78 {
79 const TestParams cases[] = {
80 {"radians", "radians(${T} (90.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatRadians(90.0f)},
81 {"degrees", "degrees(${T} (2.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatDegrees(2.0f)},
82 {"sin", "sin(${T} (3.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatSin(3.0f)},
83 {"cos", "cos(${T} (3.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatCos(3.2f)},
84 {"tan", "tan(${T} (1.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatTan(1.5f)},
85 {"asin", "asin(${T} (0.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatAsin(0.0f)},
86 {"acos", "acos(${T} (1.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatAcos(1.0f)},
87 {"atan_separate", "atan(${T} (-1.0), ${T} (-1.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT,
88 deFloatAtan2(-1.0f, -1.0f)},
89 {"atan_combined", "atan(${T} (2.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatAtanOver(2.0f)},
90 {"sinh", "sinh(${T} (1.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatSinh(1.5f)},
91 {"cosh", "cosh(${T} (1.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatCosh(1.5f)},
92 {"tanh", "tanh(${T} (1.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatTanh(1.5f)},
93 {"asinh", "asinh(${T} (2.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatAsinh(2.0f)},
94 {"acosh", "acosh(${T} (2.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatAcosh(2.0f)},
95 {"atanh", "atanh(${T} (0.8))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatAtanh(0.8f)},
96 };
97
98 addChildGroup("angle_and_trigonometry", "Angles and Trigonometry", cases, DE_LENGTH_OF_ARRAY(cases));
99 }
100 // Exponential
101 {
102 const TestParams cases[] = {
103 {"pow", "pow(${T} (1.7), ${T} (3.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatPow(1.7f, 3.5f)},
104 {"exp", "exp(${T} (4.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatExp(4.2f)},
105 {"log", "log(${T} (42.12))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatLog(42.12f)},
106 {"exp2", "exp2(${T} (6.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatExp2(6.7f)},
107 {"log2", "log2(${T} (100.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatLog2(100.0f)},
108 {"sqrt", "sqrt(${T} (10.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatSqrt(10.0f)},
109 {"inversesqrt", "inversesqrt(${T} (10.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatRsq(10.0f)},
110 };
111
112 addChildGroup("exponential", "Exponential", cases, DE_LENGTH_OF_ARRAY(cases));
113 }
114 // Common
115 {
116 const TestParams cases[] = {
117 {"abs", "abs(${T} (-42.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 42.0f},
118 {"abs", "abs(${T} (-42))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, 42.0f},
119 {"sign", "sign(${T} (-18.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, -1.0f},
120 {"sign", "sign(${T} (-18))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, -1.0f},
121 {"floor", "floor(${T} (37.3))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatFloor(37.3f)},
122 {"trunc", "trunc(${T} (-1.8))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, -1.0f},
123 {"round", "round(${T} (42.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 42.0f},
124 {"roundEven", "roundEven(${T} (1.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 2.0f},
125 {"ceil", "ceil(${T} (82.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatCeil(82.2f)},
126 {"fract", "fract(${T} (17.75))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatFrac(17.75f)},
127 {"mod", "mod(${T} (87.65), ${MT} (3.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, deFloatMod(87.65f, 3.7f)},
128 // modf cannot be tested due to lacking valid ways of using the 'out' parameter in a constant expression
129 {"min", "min(${T} (12.3), ${MT} (32.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 12.3f},
130 {"min", "min(${T} (13), ${MT} (-14))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, -14.0f},
131 {"min", "min(${T} (13), ${MT} (14))", glu::TYPE_UINT, 1, 4, glu::TYPE_UINT, 13.0f},
132 {"max", "max(${T} (12.3), ${MT} (32.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 32.1f},
133 {"max", "max(${T} (13), ${MT} (-14))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, 13.0f},
134 {"max", "max(${T} (13), ${MT} (14))", glu::TYPE_UINT, 1, 4, glu::TYPE_UINT, 14.0f},
135 {"clamp", "clamp(${T} (42.1), ${MT} (10.0), ${MT} (15.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 15.0f},
136 {"clamp", "clamp(${T} (42), ${MT} (-10), ${MT} (15))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, 15.0f},
137 {"clamp", "clamp(${T} (42), ${MT} (10), ${MT} (15))", glu::TYPE_UINT, 1, 4, glu::TYPE_UINT, 15.0f},
138
139 {"mix", "mix(${T} (10.0), ${T} (20.0), ${MT}(0.75))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 17.5f},
140 {"mix_float_bool", "mix(float(10.0), float(20.0), bool(1))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 20.0f},
141 {"mix_vec2_bvec2", "mix(vec2(10.0), vec2(20.0), bvec2(1)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
142 20.0f},
143 {"mix_vec3_bvec3", "mix(vec3(10.0), vec3(20.0), bvec3(1)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
144 20.0f},
145 {"mix_vec4_bvec4", "mix(vec4(10.0), vec4(20.0), bvec4(1)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
146 20.0f},
147
148 {"step", "step(${MT} (3.2), ${T} (4.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 1.0f},
149 {"smoothstep", "smoothstep(${MT} (3.0), ${MT} (5.0), ${T} (4.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT,
150 0.5f},
151 {"isnan", "isnan(${T} (1.3))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_BOOL, 0.0f},
152 {"isinf", "isinf(${T} (1.3))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_BOOL, 0.0f},
153 {"floatbits_int", "intBitsToFloat(floatBitsToInt(42.12))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 42.12f},
154 {"floatbits_uint", "uintBitsToFloat(floatBitsToUint(-14.2))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
155 -14.2f},
156 };
157
158 addChildGroup("common", "Common", cases, DE_LENGTH_OF_ARRAY(cases));
159 }
160 // Floating point pack & unpack
161 {
162 const TestParams cases[] = {
163 {"packSnorm2x16", "packSnorm2x16(vec2(0.7, 0.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_UINT, 22937.0f},
164 {"unpackSnorm2x16", "unpackSnorm2x16(22937u).x", glu::TYPE_UINT, 1, 1, glu::TYPE_FLOAT, 0.7f},
165 {"packUnorm2x16", "packUnorm2x16(vec2(0.6, -0.3))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_UINT, 39321.0f},
166 {"unpackUnorm2x16", "unpackUnorm2x16(39321u).x", glu::TYPE_UINT, 1, 1, glu::TYPE_FLOAT, 0.6f},
167 {"packHalf2x16", "unpackHalf2x16(packHalf2x16(vec2(0.3, 0.1))).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
168 0.3f},
169 // \todo [2014-01-29 otto] Separate testing of half-precision pack & unpack
170 };
171
172 addChildGroup("float_pack_unpack", "Floating point pack & unpack", cases, DE_LENGTH_OF_ARRAY(cases));
173 }
174 // Geometric
175 {
176 const TestParams cases[] = {
177 {"length_float", "length(1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 1.0f},
178 {"length_vec2", "length(vec2(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, deFloatSqrt(2.0f)},
179 {"length_vec3", "length(vec3(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, deFloatSqrt(3.0f)},
180 {"length_vec4", "length(vec4(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, deFloatSqrt(4.0f)},
181
182 {"distance_float", "distance(1.0, 2.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 1.0f},
183 {"distance_vec2", "distance(vec2(1.0), vec2(2.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
184 deFloatSqrt(2.0f)},
185 {"distance_vec3", "distance(vec3(1.0), vec3(2.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
186 deFloatSqrt(3.0f)},
187 {"distance_vec4", "distance(vec4(1.0), vec4(2.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
188 deFloatSqrt(4.0f)},
189
190 {"dot_float", "dot(1.0, 1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 1.0f},
191 {"dot_vec2", "dot(vec2(1.0), vec2(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.0f},
192 {"dot_vec3", "dot(vec3(1.0), vec3(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 3.0f},
193 {"dot_vec4", "dot(vec4(1.0), vec4(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 4.0f},
194
195 {"normalize_float", "normalize(1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 1.0f},
196 {"normalize_vec2", "normalize(vec2(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, deFloatRsq(2.0f)},
197 {"normalize_vec3", "normalize(vec3(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, deFloatRsq(3.0f)},
198 {"normalize_vec4", "normalize(vec4(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, deFloatRsq(4.0f)},
199
200 {"faceforward", "faceforward(${T} (1.0), ${T} (1.0), ${T} (1.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT,
201 -1.0f},
202
203 // reflect(I, N) => I - 2*dot(N, I)*N
204 {"reflect_float", "reflect(1.0, 1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, -1.0f},
205 {"reflect_vec2", "reflect(vec2(1.0), vec2(1.0, 0.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, -1.0f},
206 {"reflect_vec3", "reflect(vec3(1.0), vec3(1.0, 0.0, 0.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
207 -1.0f},
208 {"reflect_vec4", "reflect(vec4(1.0), vec4(1.0, 0.0, 0.0, 0.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
209 -1.0f},
210
211 /*
212 genType refract(genType I, genType N, float eta) =>
213 k = 1.0 - (eta^2)*(1.0-dot(N,I)^2)
214 if k < 0 return 0.0
215 else return eta*I - (eta*dot(N,I) + sqrt(k))*N
216 */
217 {"refract_float", "refract(1.0, 1.0, 0.5)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, -1.0f},
218 {"refract_vec2", "refract(vec2(1.0), vec2(1.0, 0.0), 0.5).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
219 -1.0f},
220 {"refract_vec3", "refract(vec3(1.0), vec3(1.0, 0.0, 0.0), 0.5).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
221 -1.0f},
222 {"refract_vec4", "refract(vec4(1.0), vec4(1.0, 0.0, 0.0, 0.0), 0.5).x", glu::TYPE_FLOAT, 1, 1,
223 glu::TYPE_FLOAT, -1.0f},
224 };
225
226 addChildGroup("geometric", "Geometric", cases, DE_LENGTH_OF_ARRAY(cases));
227 }
228 // Matrix
229 {
230 const TestParams cases[] = {
231 {"compMult_mat2", "matrixCompMult(mat2(1.0), mat2(1.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
232 1.0f},
233 {"compMult_mat3", "matrixCompMult(mat3(1.0), mat3(1.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
234 1.0f},
235 {"compMult_mat4", "matrixCompMult(mat4(1.0), mat4(1.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
236 1.0f},
237 {"outerProd_mat2", "outerProduct(vec2(3.0), vec2(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
238 9.0f},
239 {"outerProd_mat3", "outerProduct(vec3(3.0), vec3(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
240 9.0f},
241 {"outerProd_mat4", "outerProduct(vec4(3.0), vec4(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
242 9.0f},
243
244 {"outerProd_mat2x3", "outerProduct(vec3(3.0), vec2(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
245 9.0f},
246 {"outerProd_mat3x2", "outerProduct(vec2(3.0), vec3(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
247 9.0f},
248 {"outerProd_mat2x4", "outerProduct(vec4(3.0), vec2(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
249 9.0f},
250 {"outerProd_mat4x2", "outerProduct(vec2(3.0), vec4(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
251 9.0f},
252 {"outerProd_mat3x4", "outerProduct(vec4(3.0), vec3(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
253 9.0f},
254 {"outerProd_mat4x3", "outerProduct(vec3(3.0), vec4(3.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT,
255 9.0f},
256
257 {"transpose_mat2", "transpose(mat2(2.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.0f},
258 {"transpose_mat3", "transpose(mat3(2.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.0f},
259 {"transpose_mat4", "transpose(mat4(2.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.0f},
260 {"transpose_mat3x2", "transpose(mat3x2(2.3))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.3f},
261 {"transpose_mat2x3", "transpose(mat2x3(2.3))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.3f},
262 {"transpose_mat4x2", "transpose(mat4x2(2.3))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.3f},
263 {"transpose_mat4x3", "transpose(mat4x3(2.3))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.3f},
264 {"transpose_mat2x4", "transpose(mat2x4(2.3))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.3f},
265 {"transpose_mat3x4", "transpose(mat3x4(2.3))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 2.3f},
266
267 {"determinant_mat2", "determinant(mat2(2.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 4.0f},
268 {"determinant_mat3", "determinant(mat3(2.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 8.0f},
269 {"determinant_mat4", "determinant(mat4(2.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 16.0f},
270
271 {"inverse_mat2", "inverse(mat2(2.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 0.5f},
272 {"inverse_mat3", "inverse(mat3(2.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 0.5f},
273 {"inverse_mat4", "inverse(mat4(2.0))[0][0]", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, 0.5f},
274 };
275
276 addChildGroup("matrix", "Matrix", cases, DE_LENGTH_OF_ARRAY(cases));
277 }
278 // Vector relational
279 {
280 const TestParams cases[] = {
281 {"lessThan", "lessThan(${T} (1.0), ${T} (2.0))", glu::TYPE_FLOAT, 2, 4, glu::TYPE_BOOL, 1.0f},
282 {"lessThan", "lessThan(${T} (-1), ${T} (2))", glu::TYPE_INT, 2, 4, glu::TYPE_BOOL, 1.0f},
283 {"lessThan", "lessThan(${T} (1), ${T} (2))", glu::TYPE_UINT, 2, 4, glu::TYPE_BOOL, 1.0f},
284 {"lessThanEqual", "lessThanEqual(${T} (1.0), ${T} (1.0))", glu::TYPE_FLOAT, 2, 4, glu::TYPE_BOOL, 1.0f},
285 {"lessThanEqual", "lessThanEqual(${T} (-1), ${T} (-1))", glu::TYPE_INT, 2, 4, glu::TYPE_BOOL, 1.0f},
286 {"lessThanEqual", "lessThanEqual(${T} (1), ${T} (1))", glu::TYPE_UINT, 2, 4, glu::TYPE_BOOL, 1.0f},
287 {"greaterThan", "greaterThan(${T} (1.0), ${T} (2.0))", glu::TYPE_FLOAT, 2, 4, glu::TYPE_BOOL, 0.0f},
288 {"greaterThan", "greaterThan(${T} (-1), ${T} (2))", glu::TYPE_INT, 2, 4, glu::TYPE_BOOL, 0.0f},
289 {"greaterThan", "greaterThan(${T} (1), ${T} (2))", glu::TYPE_UINT, 2, 4, glu::TYPE_BOOL, 0.0f},
290 {"greaterThanEqual", "greaterThanEqual(${T} (1.0), ${T} (2.0))", glu::TYPE_FLOAT, 2, 4, glu::TYPE_BOOL,
291 0.0f},
292 {"greaterThanEqual", "greaterThanEqual(${T} (-1), ${T} (2))", glu::TYPE_INT, 2, 4, glu::TYPE_BOOL, 0.0f},
293 {"greaterThanEqual", "greaterThanEqual(${T} (1), ${T} (2))", glu::TYPE_UINT, 2, 4, glu::TYPE_BOOL, 0.0f},
294 {"equal", "equal(${T} (1.0), ${T} (1.2))", glu::TYPE_FLOAT, 2, 4, glu::TYPE_BOOL, 0.0f},
295 {"equal", "equal(${T} (1), ${T} (-2))", glu::TYPE_INT, 2, 4, glu::TYPE_BOOL, 0.0f},
296 {"equal", "equal(${T} (1), ${T} (2))", glu::TYPE_UINT, 2, 4, glu::TYPE_BOOL, 0.0f},
297 {"equal", "equal(${T} (true), ${T} (false))", glu::TYPE_BOOL, 2, 4, glu::TYPE_BOOL, 0.0f},
298 {"notEqual", "notEqual(${T} (1.0), ${T} (1.2))", glu::TYPE_FLOAT, 2, 4, glu::TYPE_BOOL, 1.0f},
299 {"notEqual", "notEqual(${T} (1), ${T} (-2))", glu::TYPE_INT, 2, 4, glu::TYPE_BOOL, 1.0f},
300 {"notEqual", "notEqual(${T} (1), ${T} (2))", glu::TYPE_UINT, 2, 4, glu::TYPE_BOOL, 1.0f},
301 {"notEqual", "notEqual(${T} (true), ${T} (false))", glu::TYPE_BOOL, 2, 4, glu::TYPE_BOOL, 1.0f},
302 {"any_bvec2", "any(bvec2(true, false))", glu::TYPE_BOOL, 1, 1, glu::TYPE_BOOL, 1.0f},
303 {"any_bvec3", "any(bvec3(true, false, false))", glu::TYPE_BOOL, 1, 1, glu::TYPE_BOOL, 1.0f},
304 {"any_bvec4", "any(bvec4(true, false, false, false))", glu::TYPE_BOOL, 1, 1, glu::TYPE_BOOL, 1.0f},
305 {"all_bvec2", "all(bvec2(true, false))", glu::TYPE_BOOL, 1, 1, glu::TYPE_BOOL, 0.0f},
306 {"all_bvec3", "all(bvec3(true, false, false))", glu::TYPE_BOOL, 1, 1, glu::TYPE_BOOL, 0.0f},
307 {"all_bvec4", "all(bvec4(true, false, false, false))", glu::TYPE_BOOL, 1, 1, glu::TYPE_BOOL, 0.0f},
308 {"not", "not(${T} (false))", glu::TYPE_BOOL, 2, 4, glu::TYPE_BOOL, 1.0f},
309 };
310
311 addChildGroup("vector_relational", "Vector relational", cases, DE_LENGTH_OF_ARRAY(cases));
312 }
313 // Fragment processing (must return zero when used in initilizer with constexpr arguement)
314 {
315 const TestParams cases[] = {
316 {"dFdx", "dFdx(${T} (123.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 0.0},
317 {"dFdy", "dFdx(${T} (234.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 0.0},
318 {"fwidth", "fwidth(${T} (345.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, 0.0},
319 };
320
321 const std::vector<tcu::TestNode *> children =
322 createTests(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), cases,
323 DE_LENGTH_OF_ARRAY(cases), glu::GLSL_VERSION_300_ES, SHADER_FRAGMENT);
324 tcu::TestCaseGroup *group = new tcu::TestCaseGroup(m_testCtx, "fragment_processing", "Fragment processing");
325
326 addChild(group);
327
328 for (int i = 0; i < (int)children.size(); i++)
329 group->addChild(children[i]);
330 }
331 }
332
333 // all
ShaderConstExprTests(Context & context)334 ShaderConstExprTests::ShaderConstExprTests(Context &context)
335 : TestCaseGroup(context, "constant_expressions", "Constant expressions")
336 {
337 }
338
~ShaderConstExprTests(void)339 ShaderConstExprTests::~ShaderConstExprTests(void)
340 {
341 }
342
init(void)343 void ShaderConstExprTests::init(void)
344 {
345 const std::vector<tcu::TestNode *> children =
346 gls::ShaderLibrary(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo())
347 .loadShaderFile("shaders/constant_expressions.test");
348
349 for (int i = 0; i < (int)children.size(); i++)
350 addChild(children[i]);
351
352 addChild(new ShaderConstExprBuiltinTests(m_context));
353 }
354
355 } // namespace Functional
356 } // namespace gles3
357 } // namespace deqp
358