| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the 'License'); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an 'AS IS' BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| 'use strict'; |
| goog.provide('functional.gles3.es3fShaderLoopTests'); |
| goog.require('framework.common.tcuStringTemplate'); |
| goog.require('framework.common.tcuTestCase'); |
| goog.require('framework.delibs.debase.deMath'); |
| goog.require('framework.opengl.gluShaderUtil'); |
| goog.require('framework.opengl.gluShaderProgram'); |
| goog.require('modules.shared.glsShaderRenderCase'); |
| |
| goog.scope(function() { |
| var es3fShaderLoopTests = functional.gles3.es3fShaderLoopTests; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var deMath = framework.delibs.debase.deMath; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| var gluShaderProgram = framework.opengl.gluShaderProgram; |
| var glsShaderRenderCase = modules.shared.glsShaderRenderCase; |
| var tcuStringTemplate = framework.common.tcuStringTemplate; |
| // Repeated with for, while, do-while. Examples given as 'for' loops. |
| // Repeated for const, uniform, dynamic loops. |
| |
| /** |
| * @enum {number} |
| */ |
| es3fShaderLoopTests.LoopCase = { |
| LOOPCASE_EMPTY_BODY: 0, // for (...) { } |
| LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST: 1, // for (...) { break; <body>; } |
| LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST: 2, // for (...) { <body>; break; } |
| LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK: 3, // for (...) { <body>; if (cond) break; } |
| LOOPCASE_SINGLE_STATEMENT: 4, // for (...) statement; |
| LOOPCASE_COMPOUND_STATEMENT: 5, // for (...) { statement; statement; } |
| LOOPCASE_SEQUENCE_STATEMENT: 6, // for (...) statement, statement; |
| LOOPCASE_NO_ITERATIONS: 7, // for (i=0; i<0; i++) ... |
| LOOPCASE_SINGLE_ITERATION: 8, // for (i=0; i<1; i++) ... |
| LOOPCASE_SELECT_ITERATION_COUNT: 9, // for (i=0; i<a?b:c; i++) ... |
| LOOPCASE_CONDITIONAL_CONTINUE: 10, // for (...) { if (cond) continue; } |
| LOOPCASE_UNCONDITIONAL_CONTINUE: 11, // for (...) { <body>; continue; } |
| LOOPCASE_ONLY_CONTINUE: 12, // for (...) { continue; } |
| LOOPCASE_DOUBLE_CONTINUE: 13, // for (...) { if (cond) continue; <body>; continue; } |
| LOOPCASE_CONDITIONAL_BREAK: 14, // for (...) { if (cond) break; } |
| LOOPCASE_UNCONDITIONAL_BREAK: 15, // for (...) { <body>; break; } |
| LOOPCASE_PRE_INCREMENT: 16, // for (...; ++i) { <body>; } |
| LOOPCASE_POST_INCREMENT: 17, // for (...; i++) { <body>; } |
| LOOPCASE_MIXED_BREAK_CONTINUE: 18, |
| LOOPCASE_VECTOR_COUNTER: 19, // for (ivec3 ndx = ...; ndx.x < ndx.y; ndx.x += ndx.z) { ... } |
| LOOPCASE_101_ITERATIONS: 20, // loop for 101 iterations |
| LOOPCASE_SEQUENCE: 21, // two loops in sequence |
| LOOPCASE_NESTED: 22, // two nested loops |
| LOOPCASE_NESTED_SEQUENCE: 23, // two loops in sequence nested inside a third |
| LOOPCASE_NESTED_TRICKY_DATAFLOW_1: 24, // nested loops with tricky data flow |
| LOOPCASE_NESTED_TRICKY_DATAFLOW_2: 25 // nested loops with tricky data flow |
| }; |
| |
| /** |
| * @param {es3fShaderLoopTests.LoopCase} loopCase |
| * @return {string} |
| */ |
| es3fShaderLoopTests.getLoopCaseName = function(loopCase) { |
| /** @type {Array<string>} */ var s_names = [ |
| 'empty_body', |
| 'infinite_with_unconditional_break_first', |
| 'infinite_with_unconditional_break_last', |
| 'infinite_with_conditional_break', |
| 'single_statement', |
| 'compound_statement', |
| 'sequence_statement', |
| 'no_iterations', |
| 'single_iteration', |
| 'select_iteration_count', |
| 'conditional_continue', |
| 'unconditional_continue', |
| 'only_continue', |
| 'double_continue', |
| 'conditional_break', |
| 'unconditional_break', |
| 'pre_increment', |
| 'post_increment', |
| 'mixed_break_continue', |
| 'vector_counter', |
| '101_iterations', |
| 'sequence', |
| 'nested', |
| 'nested_sequence', |
| 'nested_tricky_dataflow_1', |
| 'nested_tricky_dataflow_2' |
| ]; |
| // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == es3fShaderLoopTests.LoopCase.LOOPCASE_LAST); |
| // DE_ASSERT(deInBounds32((int)loopCase, 0, LOOPCASE_LAST)); |
| return s_names[loopCase]; |
| }; |
| |
| // Complex loop cases. |
| |
| /*enum LoopBody |
| { |
| LOOPBODY_READ_UNIFORM = 0, |
| LOOPBODY_READ_UNIFORM_ARRAY, |
| LOOPBODY_READ_ |
| };*/ |
| |
| /** |
| * @enum {number} |
| */ |
| es3fShaderLoopTests.LoopType = { |
| LOOPTYPE_FOR: 0, |
| LOOPTYPE_WHILE: 1, |
| LOOPTYPE_DO_WHILE: 2 |
| }; |
| |
| /** |
| * @param {es3fShaderLoopTests.LoopType} loopType |
| * @return {string} |
| */ |
| es3fShaderLoopTests.getLoopTypeName = function(loopType) { |
| /** @type {Array<string>} */ var s_names = [ |
| 'for', |
| 'while', |
| 'do_while' |
| ]; |
| |
| // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) === es3fShaderLoopTests.LoopType.LOOPTYPE_LAST); |
| // DE_ASSERT(deInBounds32((int)loopType, 0, LOOPTYPE_LAST)); |
| return s_names[loopType]; |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| es3fShaderLoopTests.LoopCountType = { |
| LOOPCOUNT_CONSTANT: 0, |
| LOOPCOUNT_UNIFORM: 1, |
| LOOPCOUNT_DYNAMIC: 2 |
| }; |
| |
| /** |
| * @param {es3fShaderLoopTests.LoopCountType} countType |
| * @return {string} |
| */ |
| es3fShaderLoopTests.getLoopCountTypeName = function(countType) { |
| /** @type {Array<string>} */ var s_names = [ |
| 'constant', |
| 'uniform', |
| 'dynamic' |
| ]; |
| |
| // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == es3fShaderLoopTests.LoopCountType.LOOPCOUNT_LAST); |
| // DE_ASSERT(deInBounds32((int)countType, 0, es3fShaderLoopTests.LoopCountType.LOOPCOUNT_LAST)); |
| return s_names[countType]; |
| }; |
| |
| /** |
| * @param {glsShaderRenderCase.ShaderEvalContext} c |
| */ |
| es3fShaderLoopTests.evalLoop0Iters = function(c) { |
| var swizzled = deMath.swizzle(c.coords, [0, 1, 2]); |
| c.color[0] = swizzled[0]; |
| c.color[1] = swizzled[1]; |
| c.color[2] = swizzled[2]; |
| }; |
| |
| /** |
| * @param {glsShaderRenderCase.ShaderEvalContext} c |
| */ |
| es3fShaderLoopTests.evalLoop1Iters = function(c) { |
| var swizzled = deMath.swizzle(c.coords, [1, 2, 3]); |
| c.color[0] = swizzled[0]; |
| c.color[1] = swizzled[1]; |
| c.color[2] = swizzled[2]; |
| }; |
| |
| /** |
| * @param {glsShaderRenderCase.ShaderEvalContext} c |
| */ |
| es3fShaderLoopTests.evalLoop2Iters = function(c) { |
| var swizzled = deMath.swizzle(c.coords, [2, 3, 0]); |
| c.color[0] = swizzled[0]; |
| c.color[1] = swizzled[1]; |
| c.color[2] = swizzled[2]; |
| }; |
| |
| /** |
| * @param {glsShaderRenderCase.ShaderEvalContext} c |
| */ |
| es3fShaderLoopTests.evalLoop3Iters = function(c) { |
| var swizzled = deMath.swizzle(c.coords, [3, 0, 1]); |
| c.color[0] = swizzled[0]; |
| c.color[1] = swizzled[1]; |
| c.color[2] = swizzled[2]; |
| }; |
| |
| /** |
| * @param {number} numIters |
| * @return {glsShaderRenderCase.ShaderEvalFunc} |
| */ |
| es3fShaderLoopTests.getLoopEvalFunc = function(numIters) { |
| switch (numIters % 4) { |
| case 0: return es3fShaderLoopTests.evalLoop0Iters; |
| case 1: return es3fShaderLoopTests.evalLoop1Iters; |
| case 2: return es3fShaderLoopTests.evalLoop2Iters; |
| case 3: return es3fShaderLoopTests.evalLoop3Iters; |
| } |
| |
| throw new Error('Invalid loop iteration count.'); |
| }; |
| |
| // ShaderLoopCase |
| |
| /** |
| * @constructor |
| * @extends {glsShaderRenderCase.ShaderRenderCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {boolean} isVertexCase |
| * @param {glsShaderRenderCase.ShaderEvalFunc} evalFunc |
| * @param {string} vertShaderSource |
| * @param {string} fragShaderSource |
| */ |
| es3fShaderLoopTests.ShaderLoopCase = function(name, description, isVertexCase, evalFunc, vertShaderSource, fragShaderSource) { |
| glsShaderRenderCase.ShaderRenderCase.call(this, name, description, isVertexCase, evalFunc); |
| /** @type {string} */ this.m_vertShaderSource = vertShaderSource; |
| /** @type {string} */ this.m_fragShaderSource = fragShaderSource; |
| }; |
| |
| es3fShaderLoopTests.ShaderLoopCase.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype); |
| es3fShaderLoopTests.ShaderLoopCase.prototype.constructor = es3fShaderLoopTests.ShaderLoopCase; |
| |
| // Test case creation. |
| |
| /** |
| * @param {string} caseName |
| * @param {string} description |
| * @param {boolean} isVertexCase |
| * @param {es3fShaderLoopTests.LoopType} loopType |
| * @param {es3fShaderLoopTests.LoopCountType} loopCountType |
| * @param {gluShaderUtil.precision} loopCountPrecision |
| * @param {gluShaderUtil.DataType} loopCountDataType |
| * @return {es3fShaderLoopTests.ShaderLoopCase} |
| */ |
| es3fShaderLoopTests.createGenericLoopCase = function(caseName, description, isVertexCase, loopType, loopCountType, loopCountPrecision, loopCountDataType) { |
| /** @type {string} */ var vtx = ''; |
| /** @type {string} */ var frag = ''; |
| /** @type {string} */ var op = ''; |
| |
| vtx += '#version 300 es\n'; |
| frag += '#version 300 es\n'; |
| |
| vtx += 'in highp vec4 a_position;\n'; |
| vtx += 'in highp vec4 a_coords;\n'; |
| frag += 'layout(location = 0) out mediump vec4 o_color;\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| vtx += 'in mediump float a_one;\n'; |
| |
| if (isVertexCase) { |
| vtx += 'out mediump vec3 v_color;\n'; |
| frag += 'in mediump vec3 v_color;\n'; |
| } |
| else { |
| vtx += 'out mediump vec4 v_coords;\n'; |
| frag += 'in mediump vec4 v_coords;\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) { |
| vtx += 'out mediump float v_one;\n'; |
| frag += 'in mediump float v_one;\n'; |
| } |
| } |
| |
| // \todo [petri] Pass numLoopIters from outside? |
| /** @type {number} */ var numLoopIters = 3; |
| /** @type {boolean} */ var isIntCounter = gluShaderUtil.isDataTypeIntOrIVec(loopCountDataType); |
| |
| if (isIntCounter) { |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM || loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| op += 'uniform ${COUNTER_PRECISION} int ' + glsShaderRenderCase.getIntUniformName(numLoopIters) + ';\n'; |
| } |
| else { |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM || loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| op += 'uniform ${COUNTER_PRECISION} float ' + glsShaderRenderCase.getFloatFractionUniformName(numLoopIters) + ';\n'; |
| |
| if (numLoopIters != 1) |
| op += 'uniform ${COUNTER_PRECISION} float uf_one;\n'; |
| } |
| |
| vtx += isVertexCase ? op : ''; |
| frag += isVertexCase ? '' : op; |
| op = ''; |
| |
| vtx += "\n" + |
| "void main()\n" + |
| "{\n" + |
| " gl_Position = a_position;\n"; |
| |
| frag += "\n" + |
| "void main()\n" + |
| "{\n"; |
| |
| if (isVertexCase) |
| vtx += ' ${PRECISION} vec4 coords = a_coords;\n'; |
| else |
| frag += ' ${PRECISION} vec4 coords = v_coords;\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) { |
| if (isIntCounter) { |
| if (isVertexCase) |
| vtx += ' ${COUNTER_PRECISION} int one = int(a_one + 0.5);\n'; |
| else |
| frag += ' ${COUNTER_PRECISION} int one = int(v_one + 0.5);\n'; |
| } |
| else { |
| if (isVertexCase) |
| vtx += ' ${COUNTER_PRECISION} float one = a_one;\n'; |
| else |
| frag += ' ${COUNTER_PRECISION} float one = v_one;\n'; |
| } |
| } |
| |
| // Read array. |
| op += ' ${PRECISION} vec4 res = coords;\n'; |
| |
| // Loop iteration count. |
| /** @type {string} */ var iterMaxStr; |
| |
| if (isIntCounter) { |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) |
| iterMaxStr = numLoopIters.toString(); |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) |
| iterMaxStr = glsShaderRenderCase.getIntUniformName(numLoopIters); |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| iterMaxStr = glsShaderRenderCase.getIntUniformName(numLoopIters) + '*one'; |
| else |
| throw new Error('Loop Count Type not supported: ' + loopCountType); |
| } |
| else { |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) |
| iterMaxStr = '1.0'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) |
| iterMaxStr = 'uf_one'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| iterMaxStr = 'uf_one*one'; |
| else |
| throw new Error('Loop Count Type not supported: ' + loopCountType); |
| } |
| |
| // Loop operations. |
| /** @type {string} */ var initValue = isIntCounter ? '0' : '0.05'; |
| /** @type {string} */ var loopCountDeclStr = '' + gluShaderUtil.getPrecisionName(loopCountPrecision) + ' ' + gluShaderUtil.getDataTypeName(loopCountDataType) + ' ndx = ' + initValue; |
| /** @type {string} */ var loopCmpStr = 'ndx < ' + iterMaxStr; |
| /** @type {string} */ var incrementStr; |
| |
| if (isIntCounter) |
| incrementStr = 'ndx++'; |
| else { |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) |
| incrementStr = 'ndx += ' + (1.0 / numLoopIters); |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) |
| incrementStr = 'ndx += ' + glsShaderRenderCase.getFloatFractionUniformName(numLoopIters); |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| incrementStr = 'ndx += ' + glsShaderRenderCase.getFloatFractionUniformName(numLoopIters) + '*one'; |
| else |
| throw new Error('Loop Count Type not supported: ' + loopCountType); |
| } |
| |
| // Loop body. |
| /** @type {string} */ var loopBody = ' res = res.yzwx;\n';; |
| |
| if (loopType === es3fShaderLoopTests.LoopType.LOOPTYPE_FOR) { |
| op += ' for (' + loopCountDeclStr + '; ' + loopCmpStr + '; ' + incrementStr + ')\n' + |
| ' {\n' + |
| loopBody + |
| ' }\n'; |
| } |
| else if (loopType === es3fShaderLoopTests.LoopType.LOOPTYPE_WHILE) { |
| op += '\t' + loopCountDeclStr + ';\n' + |
| ' while (' + loopCmpStr + ')\n' + |
| ' {\n' + |
| loopBody + |
| '\t\t' + incrementStr + ';\n' + |
| ' }\n'; |
| } |
| else if (loopType === es3fShaderLoopTests.LoopType.LOOPTYPE_DO_WHILE) |
| { |
| op += '\t' + loopCountDeclStr + ';\n' + |
| ' do\n' + |
| ' {\n' + |
| loopBody + |
| '\t\t' + incrementStr + ';\n' + |
| ' } while (' + loopCmpStr + ');\n'; |
| } |
| else |
| throw new Error('Loop Type not supported: ' + loopType); |
| |
| vtx += isVertexCase ? op : ''; |
| frag += isVertexCase ? '' : op; |
| op = ''; |
| |
| if (isVertexCase) { |
| vtx += ' v_color = res.rgb;\n'; |
| frag += ' o_color = vec4(v_color.rgb, 1.0);\n'; |
| } |
| else { |
| vtx += ' v_coords = a_coords;\n'; |
| frag += ' o_color = vec4(res.rgb, 1.0);\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| vtx += ' v_one = a_one;\n'; |
| } |
| |
| vtx += '}\n'; |
| frag += '}\n'; |
| |
| // Fill in shader templates. |
| /** @type {Object} */ var params = {}; |
| params['LOOP_VAR_TYPE'] = gluShaderUtil.getDataTypeName(loopCountDataType); |
| params['PRECISION'] = 'mediump'; |
| params['COUNTER_PRECISION'] = gluShaderUtil.getPrecisionName(loopCountPrecision); |
| |
| /** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params); |
| /** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params); |
| |
| // Create the case. |
| /** @type {glsShaderRenderCase.ShaderEvalFunc} */ |
| var evalFunc = es3fShaderLoopTests.getLoopEvalFunc(numLoopIters); |
| return new es3fShaderLoopTests.ShaderLoopCase(caseName, description, isVertexCase, evalFunc, vertexShaderSource, fragmentShaderSource); |
| }; |
| |
| // \todo [petri] Generalize to float as well? |
| |
| /** |
| * @param {string} caseName |
| * @param {string} description |
| * @param {boolean} isVertexCase |
| * @param {es3fShaderLoopTests.LoopCase} loopCase |
| * @param {es3fShaderLoopTests.LoopType} loopType |
| * @param {es3fShaderLoopTests.LoopCountType} loopCountType |
| * @return {es3fShaderLoopTests.ShaderLoopCase} |
| */ |
| es3fShaderLoopTests.createSpecialLoopCase = function(caseName, description, isVertexCase, loopCase, loopType, loopCountType) { |
| /** @type {string} */ var vtx = ''; |
| /** @type {string} */ var frag = ''; |
| /** @type {string} */ var op = ''; |
| |
| vtx += '#version 300 es\n'; |
| frag += '#version 300 es\n'; |
| |
| vtx += 'in highp vec4 a_position;\n'; |
| vtx += 'in highp vec4 a_coords;\n'; |
| frag += 'layout(location = 0) out mediump vec4 o_color;\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| vtx += 'in mediump float a_one;\n'; |
| |
| // Attribute and varyings. |
| if (isVertexCase) { |
| vtx += 'out mediump vec3 v_color;\n'; |
| frag += 'in mediump vec3 v_color;\n'; |
| } |
| else { |
| vtx += 'out mediump vec4 v_coords;\n'; |
| frag += 'in mediump vec4 v_coords;\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) { |
| vtx += 'out mediump float v_one;\n'; |
| frag += 'in mediump float v_one;\n'; |
| } |
| } |
| |
| if (loopCase === es3fShaderLoopTests.LoopCase.LOOPCASE_SELECT_ITERATION_COUNT) |
| op += 'uniform bool ub_true;\n'; |
| |
| op += 'uniform ${COUNTER_PRECISION} int ui_zero, ui_one, ui_two, ui_three, ui_four, ui_five, ui_six;\n'; |
| if (loopCase === es3fShaderLoopTests.LoopCase.LOOPCASE_101_ITERATIONS) |
| op += 'uniform ${COUNTER_PRECISION} int ui_oneHundredOne;\n'; |
| |
| vtx += isVertexCase ? op : ''; |
| frag += isVertexCase ? '' : op; |
| op = ''; |
| |
| /** @type {number} */ var iterCount = 3; // value to use in loop |
| /** @type {number} */ var numIters = 3; // actual number of iterations |
| |
| vtx += '\n' + |
| 'void main()\n' + |
| '{\n' + |
| ' gl_Position = a_position;\n'; |
| |
| frag += '\n' + |
| 'void main()\n' + |
| '{\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) { |
| if (isVertexCase) |
| vtx += ' ${COUNTER_PRECISION} int one = int(a_one + 0.5);\n'; |
| else |
| frag += ' ${COUNTER_PRECISION} int one = int(v_one + 0.5);\n'; |
| } |
| |
| if (isVertexCase) |
| vtx += ' ${PRECISION} vec4 coords = a_coords;\n'; |
| else |
| frag += ' ${PRECISION} vec4 coords = v_coords;\n'; |
| |
| // Read array. |
| op += ' ${PRECISION} vec4 res = coords;\n'; |
| |
| // Handle all loop types. |
| /** @type {string} */ var counterPrecisionStr = 'mediump'; |
| /** @type {string} */ var forLoopStr = ''; |
| /** @type {string} */ var whileLoopStr = ''; |
| /** @type {string} */ var doWhileLoopPreStr = ''; |
| /** @type {string} */ var doWhileLoopPostStr = ''; |
| |
| if (loopType === es3fShaderLoopTests.LoopType.LOOPTYPE_FOR) { |
| switch (loopCase) { |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_EMPTY_BODY: |
| numIters = 0; |
| op += ' ${FOR_LOOP} {}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST: |
| numIters = 0; |
| op += ' for (;;) { break; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST: |
| numIters = 1; |
| op += ' for (;;) { res = res.yzwx; break; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK: |
| numIters = 2; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' for (;;) { res = res.yzwx; if (i == ${ONE}) break; i++; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SINGLE_STATEMENT: |
| op += ' ${FOR_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_COMPOUND_STATEMENT: |
| iterCount = 2; |
| numIters = 2 * iterCount; |
| op += ' ${FOR_LOOP} { res = res.yzwx; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SEQUENCE_STATEMENT: |
| iterCount = 2; |
| numIters = 2 * iterCount; |
| op += ' ${FOR_LOOP} res = res.yzwx, res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NO_ITERATIONS: |
| iterCount = 0; |
| numIters = 0; |
| op += ' ${FOR_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SINGLE_ITERATION: |
| iterCount = 1; |
| numIters = 1; |
| op += ' ${FOR_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SELECT_ITERATION_COUNT: |
| op += ' for (int i = 0; i < (ub_true ? ${ITER_COUNT} : 0); i++) res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_CONDITIONAL_CONTINUE: |
| numIters = iterCount - 1; |
| op += ' ${FOR_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_UNCONDITIONAL_CONTINUE: |
| op += ' ${FOR_LOOP} { res = res.yzwx; continue; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_ONLY_CONTINUE: |
| numIters = 0; |
| op += ' ${FOR_LOOP} { continue; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_DOUBLE_CONTINUE: |
| numIters = iterCount - 1; |
| op += ' ${FOR_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; continue; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_CONDITIONAL_BREAK: |
| numIters = 2; |
| op += ' ${FOR_LOOP} { if (i == ${TWO}) break; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_UNCONDITIONAL_BREAK: |
| numIters = 1; |
| op += ' ${FOR_LOOP} { res = res.yzwx; break; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_PRE_INCREMENT: |
| op += ' for (int i = 0; i < ${ITER_COUNT}; ++i) { res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_POST_INCREMENT: |
| op += ' ${FOR_LOOP} { res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_MIXED_BREAK_CONTINUE: |
| numIters = 2; |
| iterCount = 5; |
| op += ' ${FOR_LOOP} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_VECTOR_COUNTER: |
| op += ' for (${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0); i.x < i.z; i.x += i.y) { res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_101_ITERATIONS: |
| numIters = iterCount = 101; |
| op += ' ${FOR_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SEQUENCE: |
| iterCount = 5; |
| numIters = 5; |
| op += ' ${COUNTER_PRECISION} int i;\n' + |
| ' for (i = 0; i < ${TWO}; i++) { res = res.yzwx; }\n' + |
| ' for (; i < ${ITER_COUNT}; i++) { res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED: |
| numIters = 2 * iterCount; |
| op += ' for (${COUNTER_PRECISION} int i = 0; i < ${TWO}; i++)\n' + |
| ' {\n' + |
| ' for (${COUNTER_PRECISION} int j = 0; j < ${ITER_COUNT}; j++)\n' + |
| ' res = res.yzwx;\n' + |
| ' }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_SEQUENCE: |
| numIters = 3 * iterCount; |
| op += ' for (${COUNTER_PRECISION} int i = 0; i < ${ITER_COUNT}; i++)\n' + |
| ' {\n' + |
| ' for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n' + |
| ' res = res.yzwx;\n' + |
| ' for (${COUNTER_PRECISION} int j = 0; j < ${ONE}; j++)\n' + |
| ' res = res.yzwx;\n' + |
| ' }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_TRICKY_DATAFLOW_1: |
| numIters = 2; |
| op += ' ${FOR_LOOP}\n' + |
| ' {\n' + |
| ' res = coords; // ignore outer loop effect \n' + |
| ' for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n' + |
| ' res = res.yzwx;\n' + |
| ' }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_TRICKY_DATAFLOW_2: |
| numIters = iterCount; |
| op += ' ${FOR_LOOP}\n' + |
| ' {\n' + |
| ' res = coords.wxyz;\n' + |
| ' for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n' + |
| ' res = res.yzwx;\n' + |
| ' coords = res;\n' + |
| ' }\n'; |
| break; |
| |
| default: |
| throw new Error('Case not supported: ' + loopCase); |
| } |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) |
| forLoopStr = 'for (' + counterPrecisionStr + ' int i = 0; i < ' + iterCount + '; i++)'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) |
| forLoopStr = 'for (' + counterPrecisionStr + ' int i = 0; i < ' + glsShaderRenderCase.getIntUniformName(iterCount) + '; i++)'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| forLoopStr = 'for (' + counterPrecisionStr + ' int i = 0; i < one*' + glsShaderRenderCase.getIntUniformName(iterCount) + '; i++)'; |
| else |
| throw new Error('Loop Count Type not supported: ' + loopCountType); |
| } |
| else if (loopType === es3fShaderLoopTests.LoopType.LOOPTYPE_WHILE) { |
| switch (loopCase) { |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_EMPTY_BODY: |
| numIters = 0; |
| op += ' ${WHILE_LOOP} {}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST: |
| numIters = 0; |
| op += ' while (true) { break; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST: |
| numIters = 1; |
| op += ' while (true) { res = res.yzwx; break; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK: |
| numIters = 2; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (true) { res = res.yzwx; if (i == ${ONE}) break; i++; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SINGLE_STATEMENT: |
| op += ' ${WHILE_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_COMPOUND_STATEMENT: |
| iterCount = 2; |
| numIters = 2 * iterCount; |
| op += ' ${WHILE_LOOP} { res = res.yzwx; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SEQUENCE_STATEMENT: |
| iterCount = 2; |
| numIters = 2 * iterCount; |
| op += ' ${WHILE_LOOP} res = res.yzwx, res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NO_ITERATIONS: |
| iterCount = 0; |
| numIters = 0; |
| op += ' ${WHILE_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SINGLE_ITERATION: |
| iterCount = 1; |
| numIters = 1; |
| op += ' ${WHILE_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SELECT_ITERATION_COUNT: |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (i < (ub_true ? ${ITER_COUNT} : 0)) { res = res.yzwx; i++; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_CONDITIONAL_CONTINUE: |
| numIters = iterCount - 1; |
| op += ' ${WHILE_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_UNCONDITIONAL_CONTINUE: |
| op += ' ${WHILE_LOOP} { res = res.yzwx; continue; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_ONLY_CONTINUE: |
| numIters = 0; |
| op += ' ${WHILE_LOOP} { continue; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_DOUBLE_CONTINUE: |
| numIters = iterCount - 1; |
| op += ' ${WHILE_LOOP} { if (i == ${ONE}) continue; res = res.yzwx; continue; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_CONDITIONAL_BREAK: |
| numIters = 2; |
| op += ' ${WHILE_LOOP} { if (i == ${THREE}) break; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_UNCONDITIONAL_BREAK: |
| numIters = 1; |
| op += ' ${WHILE_LOOP} { res = res.yzwx; break; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_PRE_INCREMENT: |
| numIters = iterCount - 1; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (++i < ${ITER_COUNT}) { res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_POST_INCREMENT: |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (i++ < ${ITER_COUNT}) { res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_MIXED_BREAK_CONTINUE: |
| numIters = 2; |
| iterCount = 5; |
| op += ' ${WHILE_LOOP} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_VECTOR_COUNTER: |
| op += ' ${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0);\n' + |
| ' while (i.x < i.z) { res = res.yzwx; i.x += i.y; }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_101_ITERATIONS: |
| numIters = iterCount = 101; |
| op += ' ${WHILE_LOOP} res = res.yzwx;\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SEQUENCE: |
| iterCount = 6; |
| numIters = iterCount - 1; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (i++ < ${TWO}) { res = res.yzwx; }\n' + |
| ' while (i++ < ${ITER_COUNT}) { res = res.yzwx; }\n'; // \note skips one iteration |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED: |
| numIters = 2 * iterCount; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (i++ < ${TWO})\n' + |
| ' {\n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' while (j++ < ${ITER_COUNT})\n' + |
| ' res = res.yzwx;\n' + |
| ' }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_SEQUENCE: |
| numIters = 2 * iterCount; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' while (i++ < ${ITER_COUNT})\n' + |
| ' {\n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' while (j++ < ${ONE})\n' + |
| ' res = res.yzwx;\n' + |
| ' while (j++ < ${THREE})\n' + // \note skips one iteration |
| ' res = res.yzwx;\n' + |
| ' }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_TRICKY_DATAFLOW_1: |
| numIters = 2; |
| op += ' ${WHILE_LOOP}\n' + |
| ' {\n' + |
| ' res = coords; // ignore outer loop effect \n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' while (j++ < ${TWO})\n' + |
| ' res = res.yzwx;\n' + |
| ' }\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_TRICKY_DATAFLOW_2: |
| numIters = iterCount; |
| op += ' ${WHILE_LOOP}\n' + |
| ' {\n' + |
| ' res = coords.wxyz;\n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' while (j++ < ${TWO})\n' + |
| ' res = res.yzwx;\n' + |
| ' coords = res;\n' + |
| ' }\n'; |
| break; |
| |
| default: |
| throw new Error('Loop Case not supported: ' + loopCase); |
| } |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) |
| whileLoopStr = '\t' + counterPrecisionStr + ' int i = 0;\n' + ' while(i++ < ' + iterCount + ')'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) |
| whileLoopStr = '\t' + counterPrecisionStr + ' int i = 0;\n' + ' while(i++ < ' + glsShaderRenderCase.getIntUniformName(iterCount) + ')'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| whileLoopStr = '\t' + counterPrecisionStr + ' int i = 0;\n' + ' while(i++ < one*' + glsShaderRenderCase.getIntUniformName(iterCount) + ')'; |
| else |
| throw new Error('Loop Count Type not supported: ' + loopCountType); |
| } |
| else { |
| assertMsgOptions(loopType === es3fShaderLoopTests.LoopType.LOOPTYPE_DO_WHILE, 'Expected LOOPTYPE_DO_WHILE', false, true); |
| |
| switch (loopCase) { |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_EMPTY_BODY: |
| numIters = 0; |
| op += ' ${DO_WHILE_PRE} {} ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST: |
| numIters = 0; |
| op += ' do { break; res = res.yzwx; } while (true);\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST: |
| numIters = 1; |
| op += ' do { res = res.yzwx; break; } while (true);\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK: |
| numIters = 2; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do { res = res.yzwx; if (i == ${ONE}) break; i++; } while (true);\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SINGLE_STATEMENT: |
| op += ' ${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_COMPOUND_STATEMENT: |
| iterCount = 2; |
| numIters = 2 * iterCount; |
| op += ' ${DO_WHILE_PRE} { res = res.yzwx; res = res.yzwx; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SEQUENCE_STATEMENT: |
| iterCount = 2; |
| numIters = 2 * iterCount; |
| op += ' ${DO_WHILE_PRE} res = res.yzwx, res = res.yzwx; ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NO_ITERATIONS: |
| //assertMsgOptions(false, 'LOOPCASE_NO_ITERATIONS', false, false); |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SINGLE_ITERATION: |
| iterCount = 1; |
| numIters = 1; |
| op += ' ${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SELECT_ITERATION_COUNT: |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do { res = res.yzwx; } while (++i < (ub_true ? ${ITER_COUNT} : 0));\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_CONDITIONAL_CONTINUE: |
| numIters = iterCount - 1; |
| op += ' ${DO_WHILE_PRE} { if (i == ${TWO}) continue; res = res.yzwx; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_UNCONDITIONAL_CONTINUE: |
| op += ' ${DO_WHILE_PRE} { res = res.yzwx; continue; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_ONLY_CONTINUE: |
| numIters = 0; |
| op += ' ${DO_WHILE_PRE} { continue; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_DOUBLE_CONTINUE: |
| numIters = iterCount - 1; |
| op += ' ${DO_WHILE_PRE} { if (i == ${TWO}) continue; res = res.yzwx; continue; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_CONDITIONAL_BREAK: |
| numIters = 2; |
| op += ' ${DO_WHILE_PRE} { res = res.yzwx; if (i == ${ONE}) break; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_UNCONDITIONAL_BREAK: |
| numIters = 1; |
| op += ' ${DO_WHILE_PRE} { res = res.yzwx; break; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_PRE_INCREMENT: |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do { res = res.yzwx; } while (++i < ${ITER_COUNT});\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_POST_INCREMENT: |
| numIters = iterCount + 1; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do { res = res.yzwx; } while (i++ < ${ITER_COUNT});\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_MIXED_BREAK_CONTINUE: |
| numIters = 2; |
| iterCount = 5; |
| op += ' ${DO_WHILE_PRE} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_VECTOR_COUNTER: |
| op += ' ${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0);\n' + |
| ' do { res = res.yzwx; } while ((i.x += i.y) < i.z);\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_101_ITERATIONS: |
| numIters = iterCount = 101; |
| op += ' ${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_SEQUENCE: |
| iterCount = 5; |
| numIters = 5; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do { res = res.yzwx; } while (++i < ${TWO});\n' + |
| ' do { res = res.yzwx; } while (++i < ${ITER_COUNT});\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED: |
| numIters = 2 * iterCount; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do\n' + |
| ' {\n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' do\n' + |
| ' res = res.yzwx;\n' + |
| ' while (++j < ${ITER_COUNT});\n' + |
| ' } while (++i < ${TWO});\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_SEQUENCE: |
| numIters = 3 * iterCount; |
| op += ' ${COUNTER_PRECISION} int i = 0;\n' + |
| ' do\n' + |
| ' {\n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' do\n' + |
| ' res = res.yzwx;\n' + |
| ' while (++j < ${TWO});\n' + |
| ' do\n' + |
| ' res = res.yzwx;\n' + |
| ' while (++j < ${THREE});\n' + |
| ' } while (++i < ${ITER_COUNT});\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_TRICKY_DATAFLOW_1: |
| numIters = 2; |
| op += ' ${DO_WHILE_PRE}\n' + |
| ' {\n' + |
| ' res = coords; // ignore outer loop effect \n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' do\n' + |
| ' res = res.yzwx;\n' + |
| ' while (++j < ${TWO});\n' + |
| ' } ${DO_WHILE_POST}\n'; |
| break; |
| |
| case es3fShaderLoopTests.LoopCase.LOOPCASE_NESTED_TRICKY_DATAFLOW_2: |
| numIters = iterCount; |
| op += ' ${DO_WHILE_PRE}\n' + |
| ' {\n' + |
| ' res = coords.wxyz;\n' + |
| ' ${COUNTER_PRECISION} int j = 0;\n' + |
| ' while (j++ < ${TWO})\n' + |
| ' res = res.yzwx;\n' + |
| ' coords = res;\n' + |
| ' } ${DO_WHILE_POST}\n'; |
| break; |
| |
| default: |
| throw new Error('Loop Case not supported: ' + loopCase); |
| } |
| |
| doWhileLoopPreStr = '\t' + counterPrecisionStr + ' int i = 0;\n' + '\tdo '; |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) |
| doWhileLoopPostStr = ' while (++i < ' + iterCount + ');\n'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) |
| doWhileLoopPostStr = ' while (++i < ' + glsShaderRenderCase.getIntUniformName(iterCount) + ');\n'; |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| doWhileLoopPostStr = ' while (++i < one*' + glsShaderRenderCase.getIntUniformName(iterCount) + ');\n'; |
| else |
| throw new Error('Loop Count Type not supported: ' + loopCountType); |
| } |
| |
| vtx += isVertexCase ? op : ''; |
| frag += isVertexCase ? '' : op; |
| op = ''; |
| |
| // Shader footers. |
| if (isVertexCase) { |
| vtx += ' v_color = res.rgb;\n'; |
| frag += ' o_color = vec4(v_color.rgb, 1.0);\n'; |
| } |
| else { |
| vtx += ' v_coords = a_coords;\n'; |
| frag += ' o_color = vec4(res.rgb, 1.0);\n'; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) |
| vtx += ' v_one = a_one;\n'; |
| } |
| |
| vtx += '}\n'; |
| frag += '}\n'; |
| |
| // Constants. |
| /** @type {string} */ var oneStr = ''; |
| /** @type {string} */ var twoStr = ''; |
| /** @type {string} */ var threeStr = ''; |
| /** @type {string} */ var iterCountStr = ''; |
| |
| if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_CONSTANT) { |
| oneStr = '1'; |
| twoStr = '2'; |
| threeStr = '3'; |
| iterCountStr = iterCount.toString(); |
| } |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_UNIFORM) { |
| oneStr = 'ui_one'; |
| twoStr = 'ui_two'; |
| threeStr = 'ui_three'; |
| iterCountStr = glsShaderRenderCase.getIntUniformName(iterCount); |
| } |
| else if (loopCountType === es3fShaderLoopTests.LoopCountType.LOOPCOUNT_DYNAMIC) { |
| oneStr = 'one*ui_one'; |
| twoStr = 'one*ui_two'; |
| threeStr = 'one*ui_three'; |
| iterCountStr = 'one*' + glsShaderRenderCase.getIntUniformName(iterCount); |
| } |
| else throw new Error('Loop Count Type not supported: ' + loopCountType); |
| |
| // Fill in shader templates. |
| /** @type {Object} */ var params = {}; |
| params["PRECISION"] = "mediump"; |
| params["ITER_COUNT"] = iterCountStr; |
| params["COUNTER_PRECISION"] = counterPrecisionStr; |
| params["FOR_LOOP"] = forLoopStr; |
| params["WHILE_LOOP"] = whileLoopStr; |
| params["DO_WHILE_PRE"] = doWhileLoopPreStr; |
| params["DO_WHILE_POST"] = doWhileLoopPostStr; |
| params["ONE"] = oneStr; |
| params["TWO"] = twoStr; |
| params["THREE"] = threeStr; |
| |
| /** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params); |
| /** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params); |
| |
| // Create the case. |
| /** @type {glsShaderRenderCase.ShaderEvalFunc} */ |
| var evalFunc = es3fShaderLoopTests.getLoopEvalFunc(numIters); |
| return new es3fShaderLoopTests.ShaderLoopCase(caseName, description, isVertexCase, evalFunc, vertexShaderSource, fragmentShaderSource); |
| }; |
| |
| // ShaderLoopTests. |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderLoopTests.ShaderLoopTests = function() { |
| tcuTestCase.DeqpTest.call(this, 'loops', 'Loop Tests'); |
| }; |
| |
| es3fShaderLoopTests.ShaderLoopTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderLoopTests.ShaderLoopTests.prototype.constructor = es3fShaderLoopTests.ShaderLoopTests; |
| |
| es3fShaderLoopTests.ShaderLoopTests.prototype.init = function() { |
| var testGroup = tcuTestCase.runner.testCases; |
| // Loop cases. |
| |
| /** @type {Array<gluShaderProgram.shaderType>} */ var s_shaderTypes = [ |
| gluShaderProgram.shaderType.VERTEX, |
| gluShaderProgram.shaderType.FRAGMENT |
| ]; |
| |
| /** @type {Array<gluShaderUtil.DataType>} */ var s_countDataType = [ |
| gluShaderUtil.DataType.INT, |
| gluShaderUtil.DataType.FLOAT |
| ]; |
| |
| /** @type {gluShaderProgram.shaderType} */ var shaderType; |
| /** @type {string} */ var shaderTypeName; |
| /** @type {boolean} */ var isVertexCase; |
| /** @type {string} */ var name; |
| /** @type {string} */ var desc; |
| |
| for (var loopType in es3fShaderLoopTests.LoopType) { |
| /** @type {string} */ var loopTypeName = es3fShaderLoopTests.getLoopTypeName(es3fShaderLoopTests.LoopType[loopType]); |
| /** @type {tcuTestCase.DeqpTest} */ var loopTypeGroup = tcuTestCase.newTest(loopTypeName, 'Loop tests with ' + loopTypeName + ' loop type'); |
| testGroup.addChild(loopTypeGroup); |
| |
| for (var loopCountType in es3fShaderLoopTests.LoopCountType) { |
| /** @type {string} */ var loopCountName = es3fShaderLoopTests.getLoopCountTypeName(es3fShaderLoopTests.LoopCountType[loopCountType]); |
| |
| /** @type {string} */ var groupName = loopCountName + '_iterations'; |
| /** @type {string} */ var groupDesc = 'Loop tests with ' + loopCountName + ' loop counter.'; |
| |
| /** @type {tcuTestCase.DeqpTest} */ var group = tcuTestCase.newTest(groupName, groupDesc); |
| loopTypeGroup.addChild(group); |
| |
| // Generic cases. |
| |
| for (var precision in gluShaderUtil.precision) { |
| /** @type {string} */ var precisionName = gluShaderUtil.getPrecisionName(gluShaderUtil.precision[precision]); |
| |
| for (var dataTypeNdx = 0; dataTypeNdx < s_countDataType.length; dataTypeNdx++) { |
| /** @type {gluShaderUtil.DataType} */ var loopDataType = s_countDataType[dataTypeNdx]; |
| /** @type {string} */ var dataTypeName = gluShaderUtil.getDataTypeName(loopDataType); |
| |
| for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) { |
| shaderType = s_shaderTypes[shaderTypeNdx]; |
| shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType); |
| isVertexCase = (shaderType == gluShaderProgram.shaderType.VERTEX); |
| |
| |
| name = 'basic_' + precisionName + '_' + dataTypeName + '_' + shaderTypeName; |
| desc = loopTypeName + ' loop with ' + precisionName + dataTypeName + ' ' + loopCountName + ' iteration count in ' + shaderTypeName + ' shader.'; |
| group.addChild(es3fShaderLoopTests.createGenericLoopCase(name, desc, isVertexCase, es3fShaderLoopTests.LoopType[loopType], es3fShaderLoopTests.LoopCountType[loopCountType], gluShaderUtil.precision[precision], loopDataType)); |
| } |
| } |
| } |
| |
| // Special cases. |
| |
| for (var loopCase in es3fShaderLoopTests.LoopCase) { |
| /** @type {string} */ var loopCaseName = es3fShaderLoopTests.getLoopCaseName(es3fShaderLoopTests.LoopCase[loopCase]); |
| |
| // no-iterations not possible with do-while. |
| if ((es3fShaderLoopTests.LoopCase[loopCase] == es3fShaderLoopTests.LoopCase.LOOPCASE_NO_ITERATIONS) && (es3fShaderLoopTests.LoopType[loopType] == es3fShaderLoopTests.LoopType.LOOPTYPE_DO_WHILE)) |
| continue; |
| |
| for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) { |
| shaderType = s_shaderTypes[shaderTypeNdx]; |
| shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType); |
| isVertexCase = (shaderType == gluShaderProgram.shaderType.VERTEX); |
| |
| name = loopCaseName + '_' + shaderTypeName; |
| desc = loopCaseName + ' loop with ' + loopTypeName + ' iteration count in ' + shaderTypeName + ' shader.'; |
| group.addChild(es3fShaderLoopTests.createSpecialLoopCase(name, desc, isVertexCase, es3fShaderLoopTests.LoopCase[loopCase], es3fShaderLoopTests.LoopType[loopType], es3fShaderLoopTests.LoopCountType[loopCountType])); |
| } |
| } |
| } |
| } |
| }; |
| |
| /** |
| * Run test |
| * @param {WebGL2RenderingContext} context |
| */ |
| es3fShaderLoopTests.run = function(context, range) { |
| gl = context; |
| //Set up Test Root parameters |
| var state = tcuTestCase.runner; |
| state.setRoot(new es3fShaderLoopTests.ShaderLoopTests()); |
| |
| //Set up name and description of this test series. |
| setCurrentTestName(state.testCases.fullName()); |
| description(state.testCases.getDescription()); |
| try { |
| if (range) |
| state.setRange(range); |
| //Run test cases |
| tcuTestCase.runTestCases(); |
| } |
| catch (err) { |
| testFailedOptions('Failed to es3fShaderLoopTests.run tests', false); |
| tcuTestCase.runner.terminate(); |
| } |
| }; |
| |
| }); |
