1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.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 Random shader tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es2fRandomShaderTests.hpp"
25 #include "glsRandomShaderCase.hpp"
26 #include "deStringUtil.hpp"
27
28 namespace deqp
29 {
30 namespace gles2
31 {
32 namespace Functional
33 {
34
35 namespace
36 {
37
createRandomShaderCase(Context & context,const char * description,const rsg::ProgramParameters & baseParams,deUint32 seed,bool vertex,bool fragment)38 gls::RandomShaderCase* createRandomShaderCase (Context& context, const char* description, const rsg::ProgramParameters& baseParams, deUint32 seed, bool vertex, bool fragment)
39 {
40 rsg::ProgramParameters params = baseParams;
41
42 params.seed = seed;
43 params.vertexParameters.randomize = vertex;
44 params.fragmentParameters.randomize = fragment;
45
46 return new gls::RandomShaderCase(context.getTestContext(), context.getRenderContext(), de::toString(seed).c_str(), description, params);
47 }
48
49 class BasicExpressionGroup : public TestCaseGroup
50 {
51 public:
BasicExpressionGroup(Context & context)52 BasicExpressionGroup (Context& context)
53 : TestCaseGroup(context, "basic_expression", "Basic arithmetic expressions")
54 {
55 }
56
init(void)57 void init (void)
58 {
59 rsg::ProgramParameters params;
60
61 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
62 addChild(vertexGroup);
63
64 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
65 addChild(fragmentGroup);
66
67 tcu::TestCaseGroup* combinedGroup = new tcu::TestCaseGroup(m_testCtx, "combined", "Combined tests");
68 addChild(combinedGroup);
69
70 for (int seed = 0; seed < 100; seed++)
71 {
72 vertexGroup->addChild(createRandomShaderCase(m_context, "Random expressions in vertex shader", params, seed, true, false));
73 fragmentGroup->addChild(createRandomShaderCase(m_context, "Random expressions in fragment shader", params, seed, false, true));
74 combinedGroup->addChild(createRandomShaderCase(m_context, "Random expressions in vertex and fragment shaders", params, seed, true, true));
75 }
76 }
77 };
78
79 class ScalarConversionGroup : public TestCaseGroup
80 {
81 public:
ScalarConversionGroup(Context & context)82 ScalarConversionGroup (Context& context)
83 : TestCaseGroup(context, "scalar_conversion", "Scalar conversions")
84 {
85 }
86
init(void)87 void init (void)
88 {
89 rsg::ProgramParameters params;
90 params.useScalarConversions = true;
91
92 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
93 addChild(vertexGroup);
94
95 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
96 addChild(fragmentGroup);
97
98 tcu::TestCaseGroup* combinedGroup = new tcu::TestCaseGroup(m_testCtx, "combined", "Combined tests");
99 addChild(combinedGroup);
100
101 for (int seed = 0; seed < 100; seed++)
102 {
103 vertexGroup->addChild(createRandomShaderCase(m_context, "Scalar conversions in vertex shader", params, seed, true, false));
104 fragmentGroup->addChild(createRandomShaderCase(m_context, "Scalar conversions in fragment shader", params, seed, false, true));
105 combinedGroup->addChild(createRandomShaderCase(m_context, "Scalar conversions in vertex and fragment shaders", params, seed, true, true));
106 }
107 }
108 };
109
110 class SwizzleGroup : public TestCaseGroup
111 {
112 public:
SwizzleGroup(Context & context)113 SwizzleGroup (Context& context)
114 : TestCaseGroup(context, "swizzle", "Vector swizzles")
115 {
116 }
117
init(void)118 void init (void)
119 {
120 rsg::ProgramParameters params;
121 params.useScalarConversions = true;
122 params.useSwizzle = true;
123
124 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
125 addChild(vertexGroup);
126
127 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
128 addChild(fragmentGroup);
129
130 for (int seed = 0; seed < 50; seed++)
131 {
132 vertexGroup->addChild(createRandomShaderCase(m_context, "Vector swizzles in vertex shader", params, seed, true, false));
133 fragmentGroup->addChild(createRandomShaderCase(m_context, "Vector swizzles in fragment shader", params, seed, false, true));
134 }
135 }
136 };
137
138 class ComparisonOpsGroup : public TestCaseGroup
139 {
140 public:
ComparisonOpsGroup(Context & context)141 ComparisonOpsGroup (Context& context)
142 : TestCaseGroup(context, "comparison_ops", "Comparison operators")
143 {
144 }
145
init(void)146 void init (void)
147 {
148 rsg::ProgramParameters params;
149 params.useScalarConversions = true;
150 params.useComparisonOps = true;
151
152 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
153 addChild(vertexGroup);
154
155 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
156 addChild(fragmentGroup);
157
158 for (int seed = 0; seed < 50; seed++)
159 {
160 vertexGroup->addChild(createRandomShaderCase(m_context, "Comparison operators in vertex shader", params, seed, true, false));
161 fragmentGroup->addChild(createRandomShaderCase(m_context, "Comparison operators in fragment shader", params, seed, false, true));
162 }
163 }
164 };
165
166 class ConditionalsGroup : public TestCaseGroup
167 {
168 public:
ConditionalsGroup(Context & context)169 ConditionalsGroup (Context& context)
170 : TestCaseGroup(context, "conditionals", "Conditional control flow (if-else)")
171 {
172 }
173
init(void)174 void init (void)
175 {
176 rsg::ProgramParameters params;
177 params.useScalarConversions = true;
178 params.useSwizzle = true;
179 params.useComparisonOps = true;
180 params.useConditionals = true;
181 params.vertexParameters.maxStatementDepth = 4;
182 params.vertexParameters.maxStatementsPerBlock = 5;
183 params.fragmentParameters.maxStatementDepth = 4;
184 params.fragmentParameters.maxStatementsPerBlock = 5;
185
186 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
187 addChild(vertexGroup);
188
189 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
190 addChild(fragmentGroup);
191
192 tcu::TestCaseGroup* combinedGroup = new tcu::TestCaseGroup(m_testCtx, "combined", "Combined tests");
193 addChild(combinedGroup);
194
195 for (int seed = 0; seed < 100; seed++)
196 {
197 vertexGroup->addChild(createRandomShaderCase(m_context, "Conditional control flow in vertex shader", params, seed, true, false));
198 fragmentGroup->addChild(createRandomShaderCase(m_context, "Conditional control flow in fragment shader", params, seed, false, true));
199 combinedGroup->addChild(createRandomShaderCase(m_context, "Conditional control flow in vertex and fragment shaders", params, seed, true, true));
200 }
201 }
202 };
203
204 class TrigonometricGroup : public TestCaseGroup
205 {
206 public:
TrigonometricGroup(Context & context)207 TrigonometricGroup (Context& context)
208 : TestCaseGroup(context, "trigonometric", "Trigonometric built-in functions")
209 {
210 }
211
init(void)212 void init (void)
213 {
214 rsg::ProgramParameters params;
215 params.useScalarConversions = true;
216 params.useSwizzle = true;
217 params.trigonometricBaseWeight = 4.0f;
218
219 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
220 addChild(vertexGroup);
221
222 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
223 addChild(fragmentGroup);
224
225 for (int seed = 0; seed < 100; seed++)
226 {
227 vertexGroup->addChild(createRandomShaderCase(m_context, "Trigonometric ops in vertex shader", params, seed, true, false));
228 fragmentGroup->addChild(createRandomShaderCase(m_context, "Trigonometric ops in fragment shader", params, seed, false, true));
229 }
230 }
231 };
232
233 class ExponentialGroup : public TestCaseGroup
234 {
235 public:
ExponentialGroup(Context & context)236 ExponentialGroup (Context& context)
237 : TestCaseGroup(context, "exponential", "Exponential built-in functions")
238 {
239 }
240
init(void)241 void init (void)
242 {
243 rsg::ProgramParameters params;
244 params.useScalarConversions = true;
245 params.useSwizzle = true;
246 params.exponentialBaseWeight = 4.0f;
247
248 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
249 addChild(vertexGroup);
250
251 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
252 addChild(fragmentGroup);
253
254 for (int seed = 0; seed < 100; seed++)
255 {
256 vertexGroup->addChild(createRandomShaderCase(m_context, "Exponential ops in vertex shader", params, seed, true, false));
257 fragmentGroup->addChild(createRandomShaderCase(m_context, "Exponential ops in fragment shader", params, seed, false, true));
258 }
259 }
260 };
261
262 class TextureGroup : public TestCaseGroup
263 {
264 public:
TextureGroup(Context & context)265 TextureGroup (Context& context)
266 : TestCaseGroup(context, "texture", "Texture lookups")
267 {
268 }
269
init(void)270 void init (void)
271 {
272 rsg::ProgramParameters params;
273 params.useScalarConversions = true;
274 params.useSwizzle = true;
275 params.vertexParameters.texLookupBaseWeight = 10.0f;
276 params.vertexParameters.useTexture2D = true;
277 params.vertexParameters.useTextureCube = true;
278 params.fragmentParameters.texLookupBaseWeight = 10.0f;
279 params.fragmentParameters.useTexture2D = true;
280 params.fragmentParameters.useTextureCube = true;
281
282 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
283 addChild(vertexGroup);
284
285 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
286 addChild(fragmentGroup);
287
288 // Do only 50 vertex cases and 150 fragment cases.
289 for (int seed = 0; seed < 50; seed++)
290 vertexGroup->addChild(createRandomShaderCase(m_context, "Texture lookups in vertex shader", params, seed, true, false));
291
292 for (int seed = 0; seed < 150; seed++)
293 fragmentGroup->addChild(createRandomShaderCase(m_context, "Texture lookups in fragment shader", params, seed, false, true));
294 }
295 };
296
297 class AllFeaturesGroup : public TestCaseGroup
298 {
299 public:
AllFeaturesGroup(Context & context)300 AllFeaturesGroup (Context& context)
301 : TestCaseGroup(context, "all_features", "All features enabled")
302 {
303 }
304
init(void)305 void init (void)
306 {
307 rsg::ProgramParameters params;
308 params.useScalarConversions = true;
309 params.useSwizzle = true;
310 params.useComparisonOps = true;
311 params.useConditionals = true;
312 params.trigonometricBaseWeight = 1.0f;
313 params.exponentialBaseWeight = 1.0f;
314
315 params.vertexParameters.maxStatementDepth = 4;
316 params.vertexParameters.maxStatementsPerBlock = 7;
317 params.vertexParameters.maxExpressionDepth = 7;
318 params.vertexParameters.maxCombinedVariableScalars = 64;
319 params.fragmentParameters.maxStatementDepth = 4;
320 params.fragmentParameters.maxStatementsPerBlock = 7;
321 params.fragmentParameters.maxExpressionDepth = 7;
322 params.fragmentParameters.maxCombinedVariableScalars = 64;
323
324 params.fragmentParameters.texLookupBaseWeight = 4.0f; // \note Texture lookups are enabled for fragment shaders only.
325 params.fragmentParameters.useTexture2D = true;
326 params.fragmentParameters.useTextureCube = true;
327
328 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
329 addChild(vertexGroup);
330
331 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
332 addChild(fragmentGroup);
333
334 for (int seed = 0; seed < 100; seed++)
335 {
336 vertexGroup->addChild(createRandomShaderCase(m_context, "Texture lookups in vertex shader", params, seed, true, false));
337 fragmentGroup->addChild(createRandomShaderCase(m_context, "Texture lookups in fragment shader", params, seed, false, true));
338 }
339 }
340 };
341
342 } // anonymous
343
RandomShaderTests(Context & context)344 RandomShaderTests::RandomShaderTests (Context& context)
345 : TestCaseGroup(context, "random", "Random shaders")
346 {
347 }
348
~RandomShaderTests(void)349 RandomShaderTests::~RandomShaderTests (void)
350 {
351 }
352
353 namespace
354 {
355
356 } // anonymous
357
init(void)358 void RandomShaderTests::init (void)
359 {
360 addChild(new BasicExpressionGroup (m_context));
361 addChild(new ScalarConversionGroup (m_context));
362 addChild(new SwizzleGroup (m_context));
363 addChild(new ComparisonOpsGroup (m_context));
364 addChild(new ConditionalsGroup (m_context));
365 addChild(new TrigonometricGroup (m_context));
366 addChild(new ExponentialGroup (m_context));
367 addChild(new TextureGroup (m_context));
368 addChild(new AllFeaturesGroup (m_context));
369 }
370
371 } // Functional
372 } // gles2
373 } // deqp
374