1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and/or associated documentation files (the
10 * "Materials"), to deal in the Materials without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sublicense, and/or sell copies of the Materials, and to
13 * permit persons to whom the Materials are furnished to do so, subject to
14 * the following conditions:
16 * The above copyright notice(s) and this permission notice shall be included
17 * in all copies or substantial portions of the Materials.
19 * The Materials are Confidential Information as defined by the
20 * Khronos Membership Agreement until designated non-confidential by Khronos,
21 * at which point this condition clause shall be removed.
23 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
26 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
27 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
28 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
29 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
33 * \brief Shader loop tests.
34 *//*--------------------------------------------------------------------*/
36 #include "vktShaderRenderLoopTests.hpp"
38 #include "vktShaderRender.hpp"
39 #include "tcuStringTemplate.hpp"
40 #include "gluShaderUtil.hpp"
41 #include "deStringUtil.hpp"
52 static const char* getIntUniformName (int number)
56 case 0: return "ui_zero";
57 case 1: return "ui_one";
58 case 2: return "ui_two";
59 case 3: return "ui_three";
60 case 4: return "ui_four";
61 case 5: return "ui_five";
62 case 6: return "ui_six";
63 case 7: return "ui_seven";
64 case 8: return "ui_eight";
65 case 101: return "ui_oneHundredOne";
72 static BaseUniformType getIntUniformType(int number)
76 case 1: return UI_ONE;
77 case 2: return UI_TWO;
78 case 3: return UI_THREE;
79 case 4: return UI_FOUR;
80 case 5: return UI_FIVE;
81 case 6: return UI_SIX;
82 case 7: return UI_SEVEN;
83 case 8: return UI_EIGHT;
90 static const char* getFloatFractionUniformName (int number)
94 case 1: return "uf_one";
95 case 2: return "uf_half";
96 case 3: return "uf_third";
97 case 4: return "uf_fourth";
98 case 5: return "uf_fifth";
99 case 6: return "uf_sixth";
100 case 7: return "uf_seventh";
101 case 8: return "uf_eight";
108 static BaseUniformType getFloatFractionUniformType(int number)
112 case 1: return UF_ONE;
113 case 2: return UF_HALF;
114 case 3: return UF_THIRD;
115 case 4: return UF_FOURTH;
116 case 5: return UF_FIFTH;
117 case 6: return UF_SIXTH;
118 case 7: return UF_SEVENTH;
119 case 8: return UF_EIGHTH;
134 static const char* getLoopTypeName (LoopType loopType)
136 static const char* s_names[] =
143 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPTYPE_LAST);
144 DE_ASSERT(deInBounds32((int)loopType, 0, LOOPTYPE_LAST));
145 return s_names[(int)loopType];
150 LOOPCOUNT_CONSTANT = 0,
157 // Repeated with for, while, do-while. Examples given as 'for' loops.
158 // Repeated for const, uniform, dynamic loops.
161 LOOPCASE_EMPTY_BODY = 0, // for (...) { }
162 LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST, // for (...) { break; <body>; }
163 LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST, // for (...) { <body>; break; }
164 LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK, // for (...) { <body>; if (cond) break; }
165 LOOPCASE_SINGLE_STATEMENT, // for (...) statement;
166 LOOPCASE_COMPOUND_STATEMENT, // for (...) { statement; statement; }
167 LOOPCASE_SEQUENCE_STATEMENT, // for (...) statement, statement;
168 LOOPCASE_NO_ITERATIONS, // for (i=0; i<0; i++) ...
169 LOOPCASE_SINGLE_ITERATION, // for (i=0; i<1; i++) ...
170 LOOPCASE_SELECT_ITERATION_COUNT, // for (i=0; i<a?b:c; i++) ...
171 LOOPCASE_CONDITIONAL_CONTINUE, // for (...) { if (cond) continue; }
172 LOOPCASE_UNCONDITIONAL_CONTINUE, // for (...) { <body>; continue; }
173 LOOPCASE_ONLY_CONTINUE, // for (...) { continue; }
174 LOOPCASE_DOUBLE_CONTINUE, // for (...) { if (cond) continue; <body>; $
175 LOOPCASE_CONDITIONAL_BREAK, // for (...) { if (cond) break; }
176 LOOPCASE_UNCONDITIONAL_BREAK, // for (...) { <body>; break; }
177 LOOPCASE_PRE_INCREMENT, // for (...; ++i) { <body>; }
178 LOOPCASE_POST_INCREMENT, // for (...; i++) { <body>; }
179 LOOPCASE_MIXED_BREAK_CONTINUE,
180 LOOPCASE_VECTOR_COUNTER, // for (ivec3 ndx = ...; ndx.x < ndx.y; ndx$
181 LOOPCASE_101_ITERATIONS, // loop for 101 iterations
182 LOOPCASE_SEQUENCE, // two loops in sequence
183 LOOPCASE_NESTED, // two nested loops
184 LOOPCASE_NESTED_SEQUENCE, // two loops in sequence nested inside a th$
185 LOOPCASE_NESTED_TRICKY_DATAFLOW_1, // nested loops with tricky data flow
186 LOOPCASE_NESTED_TRICKY_DATAFLOW_2, // nested loops with tricky data flow
188 //LOOPCASE_MULTI_DECLARATION, // for (int i,j,k; ...) ... -- illegal?
193 static const char* getLoopCaseName (LoopCase loopCase)
195 static const char* s_names[] =
198 "infinite_with_unconditional_break_first",
199 "infinite_with_unconditional_break_last",
200 "infinite_with_conditional_break",
202 "compound_statement",
203 "sequence_statement",
206 "select_iteration_count",
207 "conditional_continue",
208 "unconditional_continue",
212 "unconditional_break",
215 "mixed_break_continue",
221 "nested_tricky_dataflow_1",
222 "nested_tricky_dataflow_2"
223 //"multi_declaration",
226 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPCASE_LAST);
227 DE_ASSERT(deInBounds32((int)loopCase, 0, LOOPCASE_LAST));
228 return s_names[(int)loopCase];
231 static const char* getLoopCountTypeName (LoopCountType countType)
233 static const char* s_names[] =
240 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPCOUNT_LAST);
241 DE_ASSERT(deInBounds32((int)countType, 0, LOOPCOUNT_LAST));
242 return s_names[(int)countType];
245 static void evalLoop0Iters (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
246 static void evalLoop1Iters (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(1,2,3); }
247 static void evalLoop2Iters (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(2,3,0); }
248 static void evalLoop3Iters (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(3,0,1); }
250 static ShaderEvalFunc getLoopEvalFunc (int numIters)
252 switch (numIters % 4)
254 case 0: return evalLoop0Iters;
255 case 1: return evalLoop1Iters;
256 case 2: return evalLoop2Iters;
257 case 3: return evalLoop3Iters;
260 DE_FATAL("Invalid loop iteration count.");
266 class ShaderLoopCase : public ShaderRenderCase
269 ShaderLoopCase (tcu::TestContext& testCtx,
270 const std::string& name,
271 const std::string& description,
273 ShaderEvalFunc evalFunc,
274 UniformSetup* uniformSetup,
275 const std::string& vertexShaderSource,
276 const std::string& fragmentShaderSource)
277 : ShaderRenderCase (testCtx, name, description, isVertexCase, evalFunc, uniformSetup, DE_NULL)
279 m_vertShaderSource = vertexShaderSource;
280 m_fragShaderSource = fragmentShaderSource;
284 // Uniform setup tools
286 class LoopUniformSetup : public UniformSetup
289 LoopUniformSetup (std::vector<BaseUniformType>& types)
290 : m_uniformInformations(types)
293 virtual void setup (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) const;
296 std::vector<BaseUniformType> m_uniformInformations;
299 void LoopUniformSetup::setup (ShaderRenderCaseInstance& instance, const tcu::Vec4&) const
301 for (size_t i = 0; i < m_uniformInformations.size(); i++)
303 instance.useUniform((deUint32)i, m_uniformInformations[i]);
309 static de::MovePtr<ShaderLoopCase> createGenericLoopCase (tcu::TestContext& testCtx,
310 const std::string& caseName,
311 const std::string& description,
314 LoopCountType loopCountType,
315 glu::Precision loopCountPrecision,
316 glu::DataType loopCountDataType)
318 std::ostringstream vtx;
319 std::ostringstream frag;
320 std::ostringstream& op = isVertexCase ? vtx : frag;
322 vtx << "#version 310 es\n";
323 frag << "#version 310 es\n";
325 vtx << "layout(location=0) in highp vec4 a_position;\n";
326 vtx << "layout(location=1) in highp vec4 a_coords;\n";
327 frag << "layout(location=0) out mediump vec4 o_color;\n";
329 if (loopCountType == LOOPCOUNT_DYNAMIC)
330 vtx << "layout(location=3) in mediump float a_one;\n";
334 vtx << "layout(location=0) out mediump vec3 v_color;\n";
335 frag << "layout(location=0) in mediump vec3 v_color;\n";
339 vtx << "layout(location=0) out mediump vec4 v_coords;\n";
340 frag << "layout(location=0) in mediump vec4 v_coords;\n";
342 if (loopCountType == LOOPCOUNT_DYNAMIC)
344 vtx << "layout(location=1) out mediump float v_one;\n";
345 frag << "layout(location=1) in mediump float v_one;\n";
349 const int numLoopIters = 3;
350 const bool isIntCounter = isDataTypeIntOrIVec(loopCountDataType);
351 deUint32 locationCounter = 0;
352 std::vector<BaseUniformType> uniformInformations;
356 if (loopCountType == LOOPCOUNT_UNIFORM || loopCountType == LOOPCOUNT_DYNAMIC)
358 op << "layout(std140, set=0, binding=" << locationCounter << ") uniform buff"<< locationCounter <<" {\n";
359 op << " ${COUNTER_PRECISION} int " << getIntUniformName(numLoopIters) << ";\n";
361 uniformInformations.push_back(getIntUniformType(numLoopIters));
367 if (loopCountType == LOOPCOUNT_UNIFORM || loopCountType == LOOPCOUNT_DYNAMIC){
368 op << "layout(std140, set=0, binding=" << locationCounter << ") uniform buff" << locationCounter << " {\n";
369 op << " ${COUNTER_PRECISION} float " << getFloatFractionUniformName(numLoopIters) << ";\n";
371 uniformInformations.push_back(getFloatFractionUniformType(numLoopIters));
375 if (numLoopIters != 1){
376 op << "layout(std140, set=0, binding=" << locationCounter << ") uniform buff" << locationCounter << " {\n";
377 op << " ${COUNTER_PRECISION} float uf_one;\n";
379 uniformInformations.push_back(UF_ONE);
385 vtx << "void main()\n";
387 vtx << " gl_Position = a_position;\n";
390 frag << "void main()\n";
394 vtx << " ${PRECISION} vec4 coords = a_coords;\n";
396 frag << " ${PRECISION} vec4 coords = v_coords;\n";
399 if (loopCountType == LOOPCOUNT_DYNAMIC)
404 vtx << " ${COUNTER_PRECISION} int one = int(a_one + 0.5);\n";
406 frag << " ${COUNTER_PRECISION} int one = int(v_one + 0.5);\n";
411 vtx << " ${COUNTER_PRECISION} float one = a_one;\n";
413 frag << " ${COUNTER_PRECISION} float one = v_one;\n";
418 op << " ${PRECISION} vec4 res = coords;\n";
420 // Loop iteration count.
421 std::string iterMaxStr;
425 if (loopCountType == LOOPCOUNT_CONSTANT)
426 iterMaxStr = de::toString(numLoopIters);
427 else if (loopCountType == LOOPCOUNT_UNIFORM)
428 iterMaxStr = getIntUniformName(numLoopIters);
429 else if (loopCountType == LOOPCOUNT_DYNAMIC)
430 iterMaxStr = std::string(getIntUniformName(numLoopIters)) + "*one";
436 if (loopCountType == LOOPCOUNT_CONSTANT)
438 else if (loopCountType == LOOPCOUNT_UNIFORM)
439 iterMaxStr = "uf_one";
440 else if (loopCountType == LOOPCOUNT_DYNAMIC)
441 iterMaxStr = "uf_one*one";
447 std::string initValue = isIntCounter ? "0" : "0.05";
448 std::string loopCountDeclStr = "${COUNTER_PRECISION} ${LOOP_VAR_TYPE} ndx = " + initValue;
449 std::string loopCmpStr = ("ndx < " + iterMaxStr);
450 std::string incrementStr;
452 incrementStr = "ndx++";
455 if (loopCountType == LOOPCOUNT_CONSTANT)
456 incrementStr = std::string("ndx += ") + de::toString(1.0f / (float)numLoopIters);
457 else if (loopCountType == LOOPCOUNT_UNIFORM)
458 incrementStr = std::string("ndx += ") + getFloatFractionUniformName(numLoopIters);
459 else if (loopCountType == LOOPCOUNT_DYNAMIC)
460 incrementStr = std::string("ndx += ") + getFloatFractionUniformName(numLoopIters) + "*one";
466 std::string loopBody;
468 loopBody = " res = res.yzwx;\n";
470 if (loopType == LOOPTYPE_FOR)
472 op << " for (" + loopCountDeclStr + "; " + loopCmpStr + "; " + incrementStr + ")\n";
477 else if (loopType == LOOPTYPE_WHILE)
479 op << "\t" << loopCountDeclStr + ";\n";
480 op << " while (" + loopCmpStr + ")\n";
483 op << "\t\t" + incrementStr + ";\n";
486 else if (loopType == LOOPTYPE_DO_WHILE)
488 op << "\t" << loopCountDeclStr + ";\n";
492 op << "\t\t" + incrementStr + ";\n";
493 op << " } while (" + loopCmpStr + ");\n";
500 vtx << " v_color = res.rgb;\n";
501 frag << " o_color = vec4(v_color.rgb, 1.0);\n";
505 vtx << " v_coords = a_coords;\n";
506 frag << " o_color = vec4(res.rgb, 1.0);\n";
508 if (loopCountType == LOOPCOUNT_DYNAMIC)
509 vtx << " v_one = a_one;\n";
515 // Fill in shader templates.
516 std::map<std::string, std::string> params;
517 params.insert(std::pair<std::string, std::string>("LOOP_VAR_TYPE", getDataTypeName(loopCountDataType)));
518 params.insert(std::pair<std::string, std::string>("PRECISION", "mediump"));
519 params.insert(std::pair<std::string, std::string>("COUNTER_PRECISION", getPrecisionName(loopCountPrecision)));
521 tcu::StringTemplate vertTemplate(vtx.str());
522 tcu::StringTemplate fragTemplate(frag.str());
523 std::string vertexShaderSource = vertTemplate.specialize(params);
524 std::string fragmentShaderSource = fragTemplate.specialize(params);
527 ShaderEvalFunc evalFunc = getLoopEvalFunc(numLoopIters);
528 UniformSetup* uniformSetup = new LoopUniformSetup(uniformInformations);
529 return de::MovePtr<ShaderLoopCase>(new ShaderLoopCase(testCtx, caseName, description, isVertexCase, evalFunc, uniformSetup, vertexShaderSource, fragmentShaderSource));
532 static de::MovePtr<ShaderLoopCase> createSpecialLoopCase (tcu::TestContext& testCtx,
533 const std::string& caseName,
534 const std::string& description,
538 LoopCountType loopCountType)
540 std::ostringstream vtx;
541 std::ostringstream frag;
542 std::ostringstream& op = isVertexCase ? vtx : frag;
544 std::vector<BaseUniformType> uniformInformations;
545 deUint32 locationCounter = 0;
547 vtx << "#version 310 es\n";
548 frag << "#version 310 es\n";
550 vtx << "layout(location=0) in highp vec4 a_position;\n";
551 vtx << "layout(location=1) in highp vec4 a_coords;\n";
552 frag << "layout(location=0) out mediump vec4 o_color;\n";
554 if (loopCountType == LOOPCOUNT_DYNAMIC)
555 vtx << "layout(location=3) in mediump float a_one;\n";
559 vtx << "layout(location=0) out mediump vec3 v_color;\n";
560 frag << "layout(location=0) in mediump vec3 v_color;\n";
564 vtx << "layout(location=0) out mediump vec4 v_coords;\n";
565 frag << "layout(location=0) in mediump vec4 v_coords;\n";
567 if (loopCountType == LOOPCOUNT_DYNAMIC)
569 vtx << "layout(location=1) out mediump float v_one;\n";
570 frag << "layout(location=1) in mediump float v_one;\n";
574 if (loopCase == LOOPCASE_SELECT_ITERATION_COUNT) {
575 op << "layout(std140, set=0, binding=" << locationCounter << ") uniform buff" << locationCounter << " {\n";
576 op << " bool ub_true;\n";
578 uniformInformations.push_back(UB_TRUE);
585 BaseUniformType type;
588 { "ui_zero", UI_ZERO },
589 { "ui_one", UI_ONE },
590 { "ui_two", UI_TWO },
591 { "ui_three", UI_THREE },
592 { "ui_four", UI_FOUR },
593 { "ui_five", UI_FIVE },
594 { "ui_six", UI_SIX },
597 for (int i = 0; i < DE_LENGTH_OF_ARRAY(uniforms); ++i)
599 op << "layout(std140, set=0, binding=" << locationCounter << ") uniform buff" << locationCounter << " {\n";
600 op << " ${COUNTER_PRECISION} int " << uniforms[i].name << ";\n";
602 uniformInformations.push_back(uniforms[i].type);
606 if (loopCase == LOOPCASE_101_ITERATIONS) {
608 op << "layout(std140, set=0, binding=" << locationCounter << ") uniform buff" << locationCounter << " {\n";
609 op << " ${COUNTER_PRECISION} int ui_oneHundredOne;\n";
611 uniformInformations.push_back(UI_ONEHUNDREDONE);
615 int iterCount = 3; // value to use in loop
616 int numIters = 3; // actual number of iterations
619 vtx << "void main()\n";
621 vtx << " gl_Position = a_position;\n";
624 frag << "void main()\n";
627 if (loopCountType == LOOPCOUNT_DYNAMIC)
630 vtx << " ${COUNTER_PRECISION} int one = int(a_one + 0.5);\n";
632 frag << " ${COUNTER_PRECISION} int one = int(v_one + 0.5);\n";
636 vtx << " ${PRECISION} vec4 coords = a_coords;\n";
638 frag << " ${PRECISION} vec4 coords = v_coords;\n";
641 op << " ${PRECISION} vec4 res = coords;\n";
643 // Handle all loop types.
644 std::string counterPrecisionStr = "mediump";
645 std::string forLoopStr;
646 std::string whileLoopStr;
647 std::string doWhileLoopPreStr;
648 std::string doWhileLoopPostStr;
650 if (loopType == LOOPTYPE_FOR)
654 case LOOPCASE_EMPTY_BODY:
656 op << " ${FOR_LOOP} {}\n";
659 case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST:
661 op << " for (;;) { break; res = res.yzwx; }\n";
664 case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST:
666 op << " for (;;) { res = res.yzwx; break; }\n";
669 case LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK:
671 op << " ${COUNTER_PRECISION} int i = 0;\n";
672 op << " for (;;) { res = res.yzwx; if (i == ${ONE}) break; i++; }\n";
675 case LOOPCASE_SINGLE_STATEMENT:
676 op << " ${FOR_LOOP} res = res.yzwx;\n";
679 case LOOPCASE_COMPOUND_STATEMENT:
681 numIters = 2 * iterCount;
682 op << " ${FOR_LOOP} { res = res.yzwx; res = res.yzwx; }\n";
685 case LOOPCASE_SEQUENCE_STATEMENT:
687 numIters = 2 * iterCount;
688 op << " ${FOR_LOOP} res = res.yzwx, res = res.yzwx;\n";
691 case LOOPCASE_NO_ITERATIONS:
694 op << " ${FOR_LOOP} res = res.yzwx;\n";
697 case LOOPCASE_SINGLE_ITERATION:
700 op << " ${FOR_LOOP} res = res.yzwx;\n";
703 case LOOPCASE_SELECT_ITERATION_COUNT:
704 op << " for (int i = 0; i < (ub_true ? ${ITER_COUNT} : 0); i++) res = res.yzwx;\n";
707 case LOOPCASE_CONDITIONAL_CONTINUE:
708 numIters = iterCount - 1;
709 op << " ${FOR_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; }\n";
712 case LOOPCASE_UNCONDITIONAL_CONTINUE:
713 op << " ${FOR_LOOP} { res = res.yzwx; continue; }\n";
716 case LOOPCASE_ONLY_CONTINUE:
718 op << " ${FOR_LOOP} { continue; }\n";
721 case LOOPCASE_DOUBLE_CONTINUE:
722 numIters = iterCount - 1;
723 op << " ${FOR_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; continue; }\n";
726 case LOOPCASE_CONDITIONAL_BREAK:
728 op << " ${FOR_LOOP} { if (i == ${TWO}) break; res = res.yzwx; }\n";
731 case LOOPCASE_UNCONDITIONAL_BREAK:
733 op << " ${FOR_LOOP} { res = res.yzwx; break; }\n";
736 case LOOPCASE_PRE_INCREMENT:
737 op << " for (int i = 0; i < ${ITER_COUNT}; ++i) { res = res.yzwx; }\n";
740 case LOOPCASE_POST_INCREMENT:
741 op << " ${FOR_LOOP} { res = res.yzwx; }\n";
744 case LOOPCASE_MIXED_BREAK_CONTINUE:
747 op << " ${FOR_LOOP} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; }\n";
750 case LOOPCASE_VECTOR_COUNTER:
751 op << " for (${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0); i.x < i.z; i.x += i.y) { res = res.yzwx; }\n";
754 case LOOPCASE_101_ITERATIONS:
755 numIters = iterCount = 101;
756 op << " ${FOR_LOOP} res = res.yzwx;\n";
759 case LOOPCASE_SEQUENCE:
762 op << " ${COUNTER_PRECISION} int i;\n";
763 op << " for (i = 0; i < ${TWO}; i++) { res = res.yzwx; }\n";
764 op << " for (; i < ${ITER_COUNT}; i++) { res = res.yzwx; }\n";
767 case LOOPCASE_NESTED:
768 numIters = 2 * iterCount;
769 op << " for (${COUNTER_PRECISION} int i = 0; i < ${TWO}; i++)\n";
771 op << " for (${COUNTER_PRECISION} int j = 0; j < ${ITER_COUNT}; j++)\n";
772 op << " res = res.yzwx;\n";
776 case LOOPCASE_NESTED_SEQUENCE:
777 numIters = 3 * iterCount;
778 op << " for (${COUNTER_PRECISION} int i = 0; i < ${ITER_COUNT}; i++)\n";
780 op << " for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n";
781 op << " res = res.yzwx;\n";
782 op << " for (${COUNTER_PRECISION} int j = 0; j < ${ONE}; j++)\n";
783 op << " res = res.yzwx;\n";
787 case LOOPCASE_NESTED_TRICKY_DATAFLOW_1:
789 op << " ${FOR_LOOP}\n";
791 op << " res = coords; // ignore outer loop effect \n";
792 op << " for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n";
793 op << " res = res.yzwx;\n";
797 case LOOPCASE_NESTED_TRICKY_DATAFLOW_2:
798 numIters = iterCount;
799 op << " ${FOR_LOOP}\n";
801 op << " res = coords.wxyz;\n";
802 op << " for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n";
803 op << " res = res.yzwx;\n";
804 op << " coords = res;\n";
812 if (loopCountType == LOOPCOUNT_CONSTANT)
813 forLoopStr = std::string("for (") + counterPrecisionStr + " int i = 0; i < " + de::toString(iterCount) + "; i++)";
814 else if (loopCountType == LOOPCOUNT_UNIFORM)
815 forLoopStr = std::string("for (") + counterPrecisionStr + " int i = 0; i < " + getIntUniformName(iterCount) + "; i++)";
816 else if (loopCountType == LOOPCOUNT_DYNAMIC)
817 forLoopStr = std::string("for (") + counterPrecisionStr + " int i = 0; i < one*" + getIntUniformName(iterCount) + "; i++)";
821 else if (loopType == LOOPTYPE_WHILE)
825 case LOOPCASE_EMPTY_BODY:
827 op << " ${WHILE_LOOP} {}\n";
830 case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST:
832 op << " while (true) { break; res = res.yzwx; }\n";
835 case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST:
837 op << " while (true) { res = res.yzwx; break; }\n";
840 case LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK:
842 op << " ${COUNTER_PRECISION} int i = 0;\n";
843 op << " while (true) { res = res.yzwx; if (i == ${ONE}) break; i++; }\n";
846 case LOOPCASE_SINGLE_STATEMENT:
847 op << " ${WHILE_LOOP} res = res.yzwx;\n";
850 case LOOPCASE_COMPOUND_STATEMENT:
852 numIters = 2 * iterCount;
853 op << " ${WHILE_LOOP} { res = res.yzwx; res = res.yzwx; }\n";
856 case LOOPCASE_SEQUENCE_STATEMENT:
858 numIters = 2 * iterCount;
859 op << " ${WHILE_LOOP} res = res.yzwx, res = res.yzwx;\n";
862 case LOOPCASE_NO_ITERATIONS:
865 op << " ${WHILE_LOOP} res = res.yzwx;\n";
868 case LOOPCASE_SINGLE_ITERATION:
871 op << " ${WHILE_LOOP} res = res.yzwx;\n";
874 case LOOPCASE_SELECT_ITERATION_COUNT:
875 op << " ${COUNTER_PRECISION} int i = 0;\n";
876 op << " while (i < (ub_true ? ${ITER_COUNT} : 0)) { res = res.yzwx; i++; }\n";
879 case LOOPCASE_CONDITIONAL_CONTINUE:
880 numIters = iterCount - 1;
881 op << " ${WHILE_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; }\n";
884 case LOOPCASE_UNCONDITIONAL_CONTINUE:
885 op << " ${WHILE_LOOP} { res = res.yzwx; continue; }\n";
888 case LOOPCASE_ONLY_CONTINUE:
890 op << " ${WHILE_LOOP} { continue; }\n";
893 case LOOPCASE_DOUBLE_CONTINUE:
894 numIters = iterCount - 1;
895 op << " ${WHILE_LOOP} { if (i == ${ONE}) continue; res = res.yzwx; continue; }\n";
898 case LOOPCASE_CONDITIONAL_BREAK:
900 op << " ${WHILE_LOOP} { if (i == ${THREE}) break; res = res.yzwx; }\n";
903 case LOOPCASE_UNCONDITIONAL_BREAK:
905 op << " ${WHILE_LOOP} { res = res.yzwx; break; }\n";
908 case LOOPCASE_PRE_INCREMENT:
909 numIters = iterCount - 1;
910 op << " ${COUNTER_PRECISION} int i = 0;\n";
911 op << " while (++i < ${ITER_COUNT}) { res = res.yzwx; }\n";
914 case LOOPCASE_POST_INCREMENT:
915 op << " ${COUNTER_PRECISION} int i = 0;\n";
916 op << " while (i++ < ${ITER_COUNT}) { res = res.yzwx; }\n";
919 case LOOPCASE_MIXED_BREAK_CONTINUE:
922 op << " ${WHILE_LOOP} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; }\n";
925 case LOOPCASE_VECTOR_COUNTER:
926 op << " ${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0);\n";
927 op << " while (i.x < i.z) { res = res.yzwx; i.x += i.y; }\n";
930 case LOOPCASE_101_ITERATIONS:
931 numIters = iterCount = 101;
932 op << " ${WHILE_LOOP} res = res.yzwx;\n";
935 case LOOPCASE_SEQUENCE:
937 numIters = iterCount - 1;
938 op << " ${COUNTER_PRECISION} int i = 0;\n";
939 op << " while (i++ < ${TWO}) { res = res.yzwx; }\n";
940 op << " while (i++ < ${ITER_COUNT}) { res = res.yzwx; }\n"; // \note skips one iteration
943 case LOOPCASE_NESTED:
944 numIters = 2 * iterCount;
945 op << " ${COUNTER_PRECISION} int i = 0;\n";
946 op << " while (i++ < ${TWO})\n";
948 op << " ${COUNTER_PRECISION} int j = 0;\n";
949 op << " while (j++ < ${ITER_COUNT})\n";
950 op << " res = res.yzwx;\n";
954 case LOOPCASE_NESTED_SEQUENCE:
955 numIters = 2 * iterCount;
956 op << " ${COUNTER_PRECISION} int i = 0;\n";
957 op << " while (i++ < ${ITER_COUNT})\n";
959 op << " ${COUNTER_PRECISION} int j = 0;\n";
960 op << " while (j++ < ${ONE})\n";
961 op << " res = res.yzwx;\n";
962 op << " while (j++ < ${THREE})\n"; // \note skips one iteration
963 op << " res = res.yzwx;\n";
967 case LOOPCASE_NESTED_TRICKY_DATAFLOW_1:
969 op << " ${WHILE_LOOP}\n";
971 op << " res = coords; // ignore outer loop effect \n";
972 op << " ${COUNTER_PRECISION} int j = 0;\n";
973 op << " while (j++ < ${TWO})\n";
974 op << " res = res.yzwx;\n";
978 case LOOPCASE_NESTED_TRICKY_DATAFLOW_2:
979 numIters = iterCount;
980 op << " ${WHILE_LOOP}\n";
982 op << " res = coords.wxyz;\n";
983 op << " ${COUNTER_PRECISION} int j = 0;\n";
984 op << " while (j++ < ${TWO})\n";
985 op << " res = res.yzwx;\n";
986 op << " coords = res;\n";
994 if (loopCountType == LOOPCOUNT_CONSTANT)
995 whileLoopStr = std::string("\t") + counterPrecisionStr + " int i = 0;\n" + " while(i++ < " + de::toString(iterCount) + ")";
996 else if (loopCountType == LOOPCOUNT_UNIFORM)
997 whileLoopStr = std::string("\t") + counterPrecisionStr + " int i = 0;\n" + " while(i++ < " + getIntUniformName(iterCount) + ")";
998 else if (loopCountType == LOOPCOUNT_DYNAMIC)
999 whileLoopStr = std::string("\t") + counterPrecisionStr + " int i = 0;\n" + " while(i++ < one*" + getIntUniformName(iterCount) + ")";
1005 DE_ASSERT(loopType == LOOPTYPE_DO_WHILE);
1009 case LOOPCASE_EMPTY_BODY:
1011 op << " ${DO_WHILE_PRE} {} ${DO_WHILE_POST}\n";
1014 case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST:
1016 op << " do { break; res = res.yzwx; } while (true);\n";
1019 case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST:
1021 op << " do { res = res.yzwx; break; } while (true);\n";
1024 case LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK:
1026 op << " ${COUNTER_PRECISION} int i = 0;\n";
1027 op << " do { res = res.yzwx; if (i == ${ONE}) break; i++; } while (true);\n";
1030 case LOOPCASE_SINGLE_STATEMENT:
1031 op << " ${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n";
1034 case LOOPCASE_COMPOUND_STATEMENT:
1036 numIters = 2 * iterCount;
1037 op << " ${DO_WHILE_PRE} { res = res.yzwx; res = res.yzwx; } ${DO_WHILE_POST}\n";
1040 case LOOPCASE_SEQUENCE_STATEMENT:
1042 numIters = 2 * iterCount;
1043 op << " ${DO_WHILE_PRE} res = res.yzwx, res = res.yzwx; ${DO_WHILE_POST}\n";
1046 case LOOPCASE_NO_ITERATIONS:
1050 case LOOPCASE_SINGLE_ITERATION:
1053 op << " ${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n";
1056 case LOOPCASE_SELECT_ITERATION_COUNT:
1057 op << " ${COUNTER_PRECISION} int i = 0;\n";
1058 op << " do { res = res.yzwx; } while (++i < (ub_true ? ${ITER_COUNT} : 0));\n";
1061 case LOOPCASE_CONDITIONAL_CONTINUE:
1062 numIters = iterCount - 1;
1063 op << " ${DO_WHILE_PRE} { if (i == ${TWO}) continue; res = res.yzwx; } ${DO_WHILE_POST}\n";
1066 case LOOPCASE_UNCONDITIONAL_CONTINUE:
1067 op << " ${DO_WHILE_PRE} { res = res.yzwx; continue; } ${DO_WHILE_POST}\n";
1070 case LOOPCASE_ONLY_CONTINUE:
1072 op << " ${DO_WHILE_PRE} { continue; } ${DO_WHILE_POST}\n";
1075 case LOOPCASE_DOUBLE_CONTINUE:
1076 numIters = iterCount - 1;
1077 op << " ${DO_WHILE_PRE} { if (i == ${TWO}) continue; res = res.yzwx; continue; } ${DO_WHILE_POST}\n";
1080 case LOOPCASE_CONDITIONAL_BREAK:
1082 op << " ${DO_WHILE_PRE} { res = res.yzwx; if (i == ${ONE}) break; } ${DO_WHILE_POST}\n";
1085 case LOOPCASE_UNCONDITIONAL_BREAK:
1087 op << " ${DO_WHILE_PRE} { res = res.yzwx; break; } ${DO_WHILE_POST}\n";
1090 case LOOPCASE_PRE_INCREMENT:
1091 op << " ${COUNTER_PRECISION} int i = 0;\n";
1092 op << " do { res = res.yzwx; } while (++i < ${ITER_COUNT});\n";
1095 case LOOPCASE_POST_INCREMENT:
1096 numIters = iterCount + 1;
1097 op << " ${COUNTER_PRECISION} int i = 0;\n";
1098 op << " do { res = res.yzwx; } while (i++ < ${ITER_COUNT});\n";
1101 case LOOPCASE_MIXED_BREAK_CONTINUE:
1104 op << " ${DO_WHILE_PRE} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; } ${DO_WHILE_POST}\n";
1107 case LOOPCASE_VECTOR_COUNTER:
1108 op << " ${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0);\n";
1109 op << " do { res = res.yzwx; } while ((i.x += i.y) < i.z);\n";
1112 case LOOPCASE_101_ITERATIONS:
1113 numIters = iterCount = 101;
1114 op << " ${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n";
1117 case LOOPCASE_SEQUENCE:
1120 op << " ${COUNTER_PRECISION} int i = 0;\n";
1121 op << " do { res = res.yzwx; } while (++i < ${TWO});\n";
1122 op << " do { res = res.yzwx; } while (++i < ${ITER_COUNT});\n";
1125 case LOOPCASE_NESTED:
1126 numIters = 2 * iterCount;
1127 op << " ${COUNTER_PRECISION} int i = 0;\n";
1130 op << " ${COUNTER_PRECISION} int j = 0;\n";
1132 op << " res = res.yzwx;\n";
1133 op << " while (++j < ${ITER_COUNT});\n";
1134 op << " } while (++i < ${TWO});\n";
1137 case LOOPCASE_NESTED_SEQUENCE:
1138 numIters = 3 * iterCount;
1139 op << " ${COUNTER_PRECISION} int i = 0;\n";
1142 op << " ${COUNTER_PRECISION} int j = 0;\n";
1144 op << " res = res.yzwx;\n";
1145 op << " while (++j < ${TWO});\n";
1147 op << " res = res.yzwx;\n";
1148 op << " while (++j < ${THREE});\n";
1149 op << " } while (++i < ${ITER_COUNT});\n";
1152 case LOOPCASE_NESTED_TRICKY_DATAFLOW_1:
1154 op << " ${DO_WHILE_PRE}\n";
1156 op << " res = coords; // ignore outer loop effect \n";
1157 op << " ${COUNTER_PRECISION} int j = 0;\n";
1159 op << " res = res.yzwx;\n";
1160 op << " while (++j < ${TWO});\n";
1161 op << " } ${DO_WHILE_POST}\n";
1164 case LOOPCASE_NESTED_TRICKY_DATAFLOW_2:
1165 numIters = iterCount;
1166 op << " ${DO_WHILE_PRE}\n";
1168 op << " res = coords.wxyz;\n";
1169 op << " ${COUNTER_PRECISION} int j = 0;\n";
1170 op << " while (j++ < ${TWO})\n";
1171 op << " res = res.yzwx;\n";
1172 op << " coords = res;\n";
1173 op << " } ${DO_WHILE_POST}\n";
1180 doWhileLoopPreStr = std::string("\t") + counterPrecisionStr + " int i = 0;\n" + "\tdo ";
1181 if (loopCountType == LOOPCOUNT_CONSTANT)
1182 doWhileLoopPostStr = std::string(" while (++i < ") + de::toString(iterCount) + ");\n";
1183 else if (loopCountType == LOOPCOUNT_UNIFORM)
1184 doWhileLoopPostStr = std::string(" while (++i < ") + getIntUniformName(iterCount) + ");\n";
1185 else if (loopCountType == LOOPCOUNT_DYNAMIC)
1186 doWhileLoopPostStr = std::string(" while (++i < one*") + getIntUniformName(iterCount) + ");\n";
1194 vtx << " v_color = res.rgb;\n";
1195 frag << " o_color = vec4(v_color.rgb, 1.0);\n";
1199 vtx << " v_coords = a_coords;\n";
1200 frag << " o_color = vec4(res.rgb, 1.0);\n";
1202 if (loopCountType == LOOPCOUNT_DYNAMIC)
1203 vtx << " v_one = a_one;\n";
1212 std::string threeStr;
1213 std::string iterCountStr;
1215 if (loopCountType == LOOPCOUNT_CONSTANT)
1220 iterCountStr = de::toString(iterCount);
1222 else if (loopCountType == LOOPCOUNT_UNIFORM)
1226 threeStr = "ui_three";
1227 iterCountStr = getIntUniformName(iterCount);
1229 else if (loopCountType == LOOPCOUNT_DYNAMIC)
1231 oneStr = "one*ui_one";
1232 twoStr = "one*ui_two";
1233 threeStr = "one*ui_three";
1234 iterCountStr = std::string("one*") + getIntUniformName(iterCount);
1236 else DE_ASSERT(false);
1238 // Fill in shader templates.
1239 std::map<std::string, std::string> params;
1240 params.insert(std::pair<std::string, std::string>("PRECISION", "mediump"));
1241 params.insert(std::pair<std::string, std::string>("ITER_COUNT", iterCountStr));
1242 params.insert(std::pair<std::string, std::string>("COUNTER_PRECISION", counterPrecisionStr));
1243 params.insert(std::pair<std::string, std::string>("FOR_LOOP", forLoopStr));
1244 params.insert(std::pair<std::string, std::string>("WHILE_LOOP", whileLoopStr));
1245 params.insert(std::pair<std::string, std::string>("DO_WHILE_PRE", doWhileLoopPreStr));
1246 params.insert(std::pair<std::string, std::string>("DO_WHILE_POST", doWhileLoopPostStr));
1247 params.insert(std::pair<std::string, std::string>("ONE", oneStr));
1248 params.insert(std::pair<std::string, std::string>("TWO", twoStr));
1249 params.insert(std::pair<std::string, std::string>("THREE", threeStr));
1251 tcu::StringTemplate vertTemplate(vtx.str());
1252 tcu::StringTemplate fragTemplate(frag.str());
1253 std::string vertexShaderSource = vertTemplate.specialize(params);
1254 std::string fragmentShaderSource = fragTemplate.specialize(params);
1257 UniformSetup* uniformSetup = new LoopUniformSetup(uniformInformations);
1258 ShaderEvalFunc evalFunc = getLoopEvalFunc(numIters);
1259 return de::MovePtr<ShaderLoopCase>(new ShaderLoopCase(testCtx, caseName, description, isVertexCase, evalFunc, uniformSetup, vertexShaderSource, fragmentShaderSource));
1262 class ShaderLoopTests : public tcu::TestCaseGroup
1265 ShaderLoopTests (tcu::TestContext& testCtx);
1266 virtual ~ShaderLoopTests (void);
1268 virtual void init (void);
1271 ShaderLoopTests (const ShaderLoopTests&); // not allowed!
1272 ShaderLoopTests& operator= (const ShaderLoopTests&); // not allowed!
1275 ShaderLoopTests::ShaderLoopTests(tcu::TestContext& testCtx)
1276 : TestCaseGroup(testCtx, "loops", "Loop Tests")
1280 ShaderLoopTests::~ShaderLoopTests (void)
1284 void ShaderLoopTests::init (void)
1288 static const glu::ShaderType s_shaderTypes[] =
1290 glu::SHADERTYPE_VERTEX,
1291 glu::SHADERTYPE_FRAGMENT
1294 static const glu::DataType s_countDataType[] =
1300 TestCaseGroup* genericGroup = new TestCaseGroup(m_testCtx, "generic", "Generic loop tests.");
1301 TestCaseGroup* specialGroup = new TestCaseGroup(m_testCtx, "special", "Special loop tests.");
1302 addChild(genericGroup);
1303 addChild(specialGroup);
1305 for (int loopType = 0; loopType < LOOPTYPE_LAST; loopType++)
1307 const char* loopTypeName = getLoopTypeName((LoopType)loopType);
1309 for (int loopCountType = 0; loopCountType < LOOPCOUNT_LAST; loopCountType++)
1311 const char* loopCountName = getLoopCountTypeName((LoopCountType)loopCountType);
1313 std::string groupName = std::string(loopTypeName) + "_" + std::string(loopCountName) + "_iterations";
1314 std::string groupDesc = std::string("Loop tests with ") + loopCountName + " loop counter.";
1315 TestCaseGroup* genericSubGroup = new TestCaseGroup(m_testCtx, groupName.c_str(), groupDesc.c_str());
1316 TestCaseGroup* specialSubGroup = new TestCaseGroup(m_testCtx, groupName.c_str(), groupDesc.c_str());
1317 genericGroup->addChild(genericSubGroup);
1318 specialGroup->addChild(specialSubGroup);
1322 for (int precision = glu::PRECISION_MEDIUMP; precision < glu::PRECISION_LAST; precision++)
1324 const char* precisionName = getPrecisionName((glu::Precision)precision);
1326 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_countDataType); dataTypeNdx++)
1328 glu::DataType loopDataType = s_countDataType[dataTypeNdx];
1329 const char* dataTypeName = getDataTypeName(loopDataType);
1331 for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
1333 glu::ShaderType shaderType = s_shaderTypes[shaderTypeNdx];
1334 const char* shaderTypeName = getShaderTypeName(shaderType);
1335 bool isVertexCase = (shaderType == glu::SHADERTYPE_VERTEX);
1337 std::string testName = std::string("basic_") + precisionName + "_" + dataTypeName + "_" + shaderTypeName;
1338 std::string testDesc = std::string(loopTypeName) + " loop with " + precisionName + dataTypeName + " " + loopCountName + " iteration count in " + shaderTypeName + " shader.";
1339 de::MovePtr<ShaderLoopCase> testCase(createGenericLoopCase(m_testCtx, testName.c_str(), testDesc.c_str(), isVertexCase, (LoopType)loopType, (LoopCountType)loopCountType, (glu::Precision)precision, loopDataType));
1340 genericSubGroup->addChild(testCase.release());
1347 for (int loopCase = 0; loopCase < LOOPCASE_LAST; loopCase++)
1349 const char* loopCaseName = getLoopCaseName((LoopCase)loopCase);
1351 // no-iterations not possible with do-while.
1352 if ((loopCase == LOOPCASE_NO_ITERATIONS) && (loopType == LOOPTYPE_DO_WHILE))
1355 for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
1357 glu::ShaderType shaderType = s_shaderTypes[shaderTypeNdx];
1358 const char* shaderTypeName = getShaderTypeName(shaderType);
1359 bool isVertexCase = (shaderType == glu::SHADERTYPE_VERTEX);
1361 std::string name = std::string(loopCaseName) + "_" + shaderTypeName;
1362 std::string desc = std::string(loopCaseName) + " loop with " + loopTypeName + " iteration count in " + shaderTypeName + " shader.";
1363 de::MovePtr<ShaderLoopCase> testCase(createSpecialLoopCase(m_testCtx, name.c_str(), desc.c_str(), isVertexCase, (LoopCase)loopCase, (LoopType)loopType, (LoopCountType)loopCountType));
1364 specialSubGroup->addChild(testCase.release());
1373 tcu::TestCaseGroup* createLoopTests (tcu::TestContext& testCtx)
1375 return new ShaderLoopTests(testCtx);