path: root/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderIndexingTests.js

/*-------------------------------------------------------------------------
 * 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.es3fShaderIndexingTests');
goog.require('framework.common.tcuImageCompare');
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('framework.opengl.gluTexture');
goog.require('modules.shared.glsShaderRenderCase');

goog.scope(function() {
    /** @type {?WebGL2RenderingContext} */ var gl;
    var es3fShaderIndexingTests = functional.gles3.es3fShaderIndexingTests;
    var deMath = framework.delibs.debase.deMath;
    var glsShaderRenderCase = modules.shared.glsShaderRenderCase;
    var gluShaderUtil = framework.opengl.gluShaderUtil;
    var gluTexture = framework.opengl.gluTexture;
    var gluShaderProgram = framework.opengl.gluShaderProgram;
    var tcuTestCase = framework.common.tcuTestCase;
    var tcuStringTemplate = framework.common.tcuStringTemplate;
    /**
     * @enum {number}
     */
    es3fShaderIndexingTests.IndexAccessType = {
        STATIC: 0,
        DYNAMIC: 1,
        STATIC_LOOP: 2,
        DYNAMIC_LOOP: 3
    };

    /**
     * @param {es3fShaderIndexingTests.IndexAccessType} accessType
     * @return {string}
     */
    es3fShaderIndexingTests.getIndexAccessTypeName = function(accessType) {
        /** @type {Array<string>} */ var s_names = [
            'static',
            'dynamic',
            'static_loop',
            'dynamic_loop'
        ];
        return s_names[accessType];
    };

    /**
     * @enum {number}
     */
    es3fShaderIndexingTests.VectorAccessType = {
        DIRECT: 0,
        COMPONENT: 1,
        SUBSCRIPT_STATIC: 2,
        SUBSCRIPT_DYNAMIC: 3,
        SUBSCRIPT_STATIC_LOOP: 4,
        SUBSCRIPT_DYNAMIC_LOOP: 5
    };

    /**
     * @param {es3fShaderIndexingTests.VectorAccessType} accessType
     * @return {string}
     */
    es3fShaderIndexingTests.getVectorAccessTypeName = function(accessType) {
        /** @type {Array<string>} */ var s_names = [
            'direct',
            'component',
            'static_subscript',
            'dynamic_subscript',
            'static_loop_subscript',
            'dynamic_loop_subscript'
        ];
        assertMsgOptions(deMath.deInBounds32(accessType, 0, s_names.length), 'Index out of bounds', false, true);
        return s_names[accessType];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayCoordsFloat = function(c) {
        c.color[0] = 1.875 * c.coords[0];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayCoordsVec2 = function(c) {
        var swizzled = deMath.swizzle(c.coords, [0, 1]);
        c.color[0] = 1.875 * swizzled[0];
        c.color[1] = 1.875 * swizzled[1];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayCoordsVec3 = function(c) {
        var swizzled = deMath.swizzle(c.coords, [0, 1, 2]);
        c.color[0] = 1.875 * swizzled[0];
        c.color[1] = 1.875 * swizzled[1];
        c.color[2] = 1.875 * swizzled[2];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayCoordsVec4 = function(c) {
        c.color = deMath.scale(c.coords, 1.875);
    };

    /**
     * @param {gluShaderUtil.DataType} dataType
     * @return {function(glsShaderRenderCase.ShaderEvalContext)}
     */
    es3fShaderIndexingTests.getArrayCoordsEvalFunc = function(dataType) {
        if (dataType === gluShaderUtil.DataType.FLOAT) return es3fShaderIndexingTests.evalArrayCoordsFloat;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC2) return es3fShaderIndexingTests.evalArrayCoordsVec2;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC3) return es3fShaderIndexingTests.evalArrayCoordsVec3;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC4) return es3fShaderIndexingTests.evalArrayCoordsVec4;
        else throw new Error('Invalid data type.');
    };


    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayUniformFloat = function(c) {
        c.color[0] = 1.875 * c.constCoords[0];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayUniformVec2 = function(c) {
        var swizzled = deMath.swizzle(c.constCoords, [0, 1]);
        c.color[0] = 1.875 * swizzled[0];
        c.color[1] = 1.875 * swizzled[1];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayUniformVec3 = function(c) {
        var swizzled = deMath.swizzle(c.constCoords, [0, 1, 2]);
        c.color[0] = 1.875 * swizzled[0];
        c.color[1] = 1.875 * swizzled[1];
        c.color[2] = 1.875 * swizzled[2];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalArrayUniformVec4 = function(c) {
        c.color = deMath.scale(c.constCoords, 1.875);
    };

    /**
     * @param {gluShaderUtil.DataType} dataType
     * @return {function(glsShaderRenderCase.ShaderEvalContext)}
     */
    es3fShaderIndexingTests.getArrayUniformEvalFunc = function(dataType) {
        if (dataType === gluShaderUtil.DataType.FLOAT) return es3fShaderIndexingTests.evalArrayUniformFloat;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC2) return es3fShaderIndexingTests.evalArrayUniformVec2;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC3) return es3fShaderIndexingTests.evalArrayUniformVec3;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC4) return es3fShaderIndexingTests.evalArrayUniformVec4;
        else throw new Error('Invalid data type.');
    };

    /**
     * @constructor
     * @extends {glsShaderRenderCase.ShaderRenderCase}
     * @param {string} name
     * @param {string} description
     * @param {boolean} isVertexCase
     * @param {gluShaderUtil.DataType} varType
     * @param {function(glsShaderRenderCase.ShaderEvalContext)} evalFunc
     * @param {string} vertShaderSource
     * @param {string} fragShaderSource
     */
    es3fShaderIndexingTests.ShaderIndexingCase = function(name, description, isVertexCase, varType, evalFunc, vertShaderSource, fragShaderSource) {
        glsShaderRenderCase.ShaderRenderCase.call(this, name, description, isVertexCase, evalFunc);
        /** @type {gluShaderUtil.DataType} */ this.m_varType = varType;
        /** @type {string} */ this.m_vertShaderSource    = vertShaderSource;
        /** @type {string} */ this.m_fragShaderSource    = fragShaderSource;
    };

    es3fShaderIndexingTests.ShaderIndexingCase.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype);
    es3fShaderIndexingTests.ShaderIndexingCase.prototype.constructor = es3fShaderIndexingTests.ShaderIndexingCase;

    /**
     * @param {?WebGLProgram} programID
     * @param {Array<number>} constCoords
     */
    es3fShaderIndexingTests.ShaderIndexingCase.prototype.setupUniforms = function(programID, constCoords) {
        /** @type {(Array<number>|Float32Array)} */ var arr = [];
        /** @type {Array<number>} */ var array1d = [];
        /** @type {?WebGLUniformLocation} */ var arrLoc = gl.getUniformLocation(programID, 'u_arr');
        if (arrLoc != null) {
            if (this.m_varType === gluShaderUtil.DataType.FLOAT) {
                arr[0] = constCoords[0];
                arr[1] = constCoords[0] * 0.5;
                arr[2] = constCoords[0] * 0.25;
                arr[3] = constCoords[0] * 0.125;
                gl.uniform1fv(arrLoc, arr);
            }
            else if (this.m_varType === gluShaderUtil.DataType.FLOAT_VEC2) {
                arr[0] = deMath.swizzle(constCoords, [0, 1]);
                arr[1] = deMath.scale(deMath.swizzle(constCoords, [0, 1]), 0.5);
                arr[2] = deMath.scale(deMath.swizzle(constCoords, [0, 1]), 0.25);
                arr[3] = deMath.scale(deMath.swizzle(constCoords, [0, 1]), 0.125);
                for (var i = 0; i < arr.length; i++)
                    array1d = array1d.concat(arr[i]);
                gl.uniform2fv(arrLoc, array1d);
            }
            else if (this.m_varType === gluShaderUtil.DataType.FLOAT_VEC3) {
                arr[0] = deMath.swizzle(constCoords, [0, 1, 2]);
                arr[1] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2]), 0.5);
                arr[2] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2]), 0.25);
                arr[3] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2]), 0.125);
                for (var i = 0; i < arr.length; i++)
                    array1d = array1d.concat(arr[i]);
                gl.uniform3fv(arrLoc, array1d);
            }
            else if (this.m_varType === gluShaderUtil.DataType.FLOAT_VEC4) {
                arr[0] = deMath.swizzle(constCoords, [0,1,2,3]);
                arr[1] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2, 3]), 0.5);
                arr[2] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2, 3]), 0.25);
                arr[3] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2, 3]), 0.125);
                for (var i = 0; i < arr.length; i++)
                    array1d = array1d.concat(arr[i]);
                gl.uniform4fv(arrLoc, array1d);
            }
            else
                throw new Error('u_arr should not have location assigned in this test case');
        }
    };

    /**
     * @param  {string} caseName
     * @param  {string} description
     * @param  {gluShaderUtil.DataType} varType
     * @param  {es3fShaderIndexingTests.IndexAccessType} vertAccess
     * @param  {es3fShaderIndexingTests.IndexAccessType} fragAccess
     * @return {es3fShaderIndexingTests.ShaderIndexingCase}
     */
    es3fShaderIndexingTests.createVaryingArrayCase = function(caseName, description, varType, vertAccess, fragAccess) {
        /** @type {string} */ var vtx = '';
        vtx += '#version 300 es\n' +
               'in highp vec4 a_position;\n' +
               'in highp vec4 a_coords;\n';

        if (vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
            vtx += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
        else if (vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
            vtx += 'uniform mediump int ui_four;\n';

        vtx += 'out ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n' +
               '\n' +
               'void main()\n' +
               '{\n' +
               '    gl_Position = a_position;\n';

        if (vertAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            vtx += '    var[0] = ${VAR_TYPE}(a_coords);\n' +
                   '    var[1] = ${VAR_TYPE}(a_coords) * 0.5;\n' +
                   '    var[2] = ${VAR_TYPE}(a_coords) * 0.25;\n' +
                   '    var[3] = ${VAR_TYPE}(a_coords) * 0.125;\n';
        }
        else if (vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            vtx += '    var[ui_zero]  = ${VAR_TYPE}(a_coords);\n' +
                   '    var[ui_one]   = ${VAR_TYPE}(a_coords) * 0.5;\n' +
                   '    var[ui_two]   = ${VAR_TYPE}(a_coords) * 0.25;\n' +
                   '    var[ui_three] = ${VAR_TYPE}(a_coords) * 0.125;\n';
        }
        else if (vertAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            vtx += '	${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n' +
                   '    for (int i = 0; i < 4; i++)\n' +
                   '    {\n' +
                   '		var[i] = ${VAR_TYPE}(coords);\n' +
                   '        coords = coords * 0.5;\n' +
                   '    }\n';
        }
        else {
            assertMsgOptions(vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'Not Dynamic_Loop', false, true);
            vtx += '	${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n' +
                   '    for (int i = 0; i < ui_four; i++)\n' +
                   '    {\n' +
                   '		var[i] = ${VAR_TYPE}(coords);\n' +
                   '        coords = coords * 0.5;\n' +
                   '    }\n';
        }
        vtx += '}\n';

        /** @type {string} */ var frag = '';
        frag += '#version 300 es\n' +
                'precision mediump int;\n' +
                'layout(location = 0) out mediump vec4 o_color;\n';

        if (fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
            frag += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
        else if (fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
            frag += 'uniform int ui_four;\n';

        frag += 'in ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n' +
                '\n' +
                'void main()\n' +
                '{\n' +
                '	${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n';

        if (fragAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            frag += '    res += var[0];\n' +
                    '    res += var[1];\n' +
                    '    res += var[2];\n' +
                    '    res += var[3];\n';
        }
        else if (fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            frag += '    res += var[ui_zero];\n' +
                    '    res += var[ui_one];\n' +
                    '    res += var[ui_two];\n' +
                    '    res += var[ui_three];\n';
        }
        else if (fragAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            frag += '    for (int i = 0; i < 4; i++)\n' +
                    '        res += var[i];\n';
        }
        else {
            assertMsgOptions(fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'Not Dynamic_Loop', false, true);
            frag += '    for (int i = 0; i < ui_four; i++)\n' +
                    '        res += var[i];\n';
        }
        frag += '	o_color = vec4(res${PADDING});\n' +
                '}\n';

        // Fill in shader templates.
        /** @type {Object} */ var params = {};
	    params['VAR_TYPE'] = gluShaderUtil.getDataTypeName(varType);
	    params['ARRAY_LEN'] = '4';
	    params['PRECISION'] = 'mediump';

        if (varType === gluShaderUtil.DataType.FLOAT)
            params['PADDING'] = ', 0.0, 0.0, 1.0';
        else if (varType === gluShaderUtil.DataType.FLOAT_VEC2)
            params['PADDING'] = ', 0.0, 1.0';
        else if (varType === gluShaderUtil.DataType.FLOAT_VEC3)
            params['PADDING'] = ', 1.0';
        else
            params['PADDING'] = '';

        /** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
    	/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);

        /** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
        var evalFunc = es3fShaderIndexingTests.getArrayCoordsEvalFunc(varType);
        return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, true, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
    };

    /**
     * @param {string} caseName
     * @param {string} description
     * @param {boolean} isVertexCase
     * @param {gluShaderUtil.DataType} varType
     * @param {es3fShaderIndexingTests.IndexAccessType} readAccess
     * @return {es3fShaderIndexingTests.ShaderIndexingCase}
     */
    es3fShaderIndexingTests.createUniformArrayCase = function(caseName, description, isVertexCase, varType, readAccess) {
        /** @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 (isVertexCase) {
            vtx += 'out mediump vec4 v_color;\n';
            frag += 'in mediump vec4 v_color;\n';
        }
        else {
            vtx += 'out mediump vec4 v_coords;\n';
            frag += 'in mediump vec4 v_coords;\n';
        }

        if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
            op += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
            op += 'uniform mediump int ui_four;\n';

        op += 'uniform ${PRECISION} ${VAR_TYPE} u_arr[${ARRAY_LEN}];\n';

        vtx += isVertexCase ? op : '';
        frag += isVertexCase ? '' : op;
        op = '';

        vtx += '\n';
        vtx += 'void main()\n';
        vtx += '{\n';
        vtx += '    gl_Position = a_position;\n';

        frag += '\n';
        frag += 'void main()\n';
        frag += '{\n';

        // Read array.
        op += '	${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n';
        if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            op += '    res += u_arr[0];\n';
            op += '    res += u_arr[1];\n';
            op += '    res += u_arr[2];\n';
            op += '    res += u_arr[3];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            op += '    res += u_arr[ui_zero];\n';
            op += '    res += u_arr[ui_one];\n';
            op += '    res += u_arr[ui_two];\n';
            op += '    res += u_arr[ui_three];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            op += '    for (int i = 0; i < 4; i++)\n';
            op += '        res += u_arr[i];\n';
        }
        else {
            assertMsgOptions(readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'readAccess not supported.', false, true);
            op += '    for (int i = 0; i < ui_four; i++)\n';
            op += '        res += u_arr[i];\n';
        }

        vtx += isVertexCase ? op : '';
        frag += isVertexCase ? '' : op;
        op = '';

        if (isVertexCase) {
            vtx += '    v_color = vec4(res${PADDING});\n';
            frag += '    o_color = v_color;\n';
        }
        else {
            vtx += '    v_coords = a_coords;\n';
            frag += '    o_color = vec4(res${PADDING});\n';
        }

        vtx += '}\n';
        frag += '}\n';

        // Fill in shader templates.
        /** @type {Object} */ var params = {};
	    params['VAR_TYPE'] = gluShaderUtil.getDataTypeName(varType);
	    params['ARRAY_LEN'] = '4';
	    params['PRECISION'] = 'mediump';

        if (varType === gluShaderUtil.DataType.FLOAT)
            params['PADDING'] = ', 0.0, 0.0, 1.0';
        else if (varType === gluShaderUtil.DataType.FLOAT_VEC2)
            params['PADDING'] = ', 0.0, 1.0';
        else if (varType === gluShaderUtil.DataType.FLOAT_VEC3)
            params['PADDING'] = ', 1.0';
        else
            params['PADDING'] = '';


        /** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
        /** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);

        /** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
        var evalFunc = es3fShaderIndexingTests.getArrayUniformEvalFunc(varType);
        return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
    };

    /**
     * @param {string} caseName
     * @param {string} description
     * @param {boolean} isVertexCase
     * @param {gluShaderUtil.DataType} varType
     * @param {es3fShaderIndexingTests.IndexAccessType} writeAccess
     * @param {es3fShaderIndexingTests.IndexAccessType} readAccess
     * @return {es3fShaderIndexingTests.ShaderIndexingCase}
     */
    es3fShaderIndexingTests.createTmpArrayCase = function(caseName, description, isVertexCase, varType, writeAccess, readAccess)    {
        /** @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' +
               'in highp vec4 a_coords;\n';
        frag += 'layout(location = 0) out mediump vec4 o_color;\n';

        if (isVertexCase) {
            vtx += 'out mediump vec4 v_color;\n';
            frag += 'in mediump vec4 v_color;\n';
        }
        else {
            vtx += 'out mediump vec4 v_coords;\n';
            frag += 'in mediump vec4 v_coords;\n';
        }

        if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
            op += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';

        if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
            op += 'uniform mediump int ui_four;\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';

        // Write array.
        if (isVertexCase)
            op += '	${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n';
        else
            op += '	${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n';

        op += '	${PRECISION} ${VAR_TYPE} arr[${ARRAY_LEN}];\n';
        if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            op += '	arr[0] = ${VAR_TYPE}(coords);\n' +
    		      '	arr[1] = ${VAR_TYPE}(coords) * 0.5;\n' +
    		      '	arr[2] = ${VAR_TYPE}(coords) * 0.25;\n' +
    		      '	arr[3] = ${VAR_TYPE}(coords) * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
    		op += '	arr[ui_zero]  = ${VAR_TYPE}(coords);\n' +
    		      '	arr[ui_one]   = ${VAR_TYPE}(coords) * 0.5;\n' +
    		      '	arr[ui_two]   = ${VAR_TYPE}(coords) * 0.25;\n' +
    		      '	arr[ui_three] = ${VAR_TYPE}(coords) * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            op += '    for (int i = 0; i < 4; i++)\n' +
                  '    {\n' +
                  '        arr[i] = ${VAR_TYPE}(coords);\n' +
                  '        coords = coords * 0.5;\n' +
                  '    }\n';
        }
        else {
            assertMsgOptions(writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'writeAccess not supported', false, true);
            op += '    for (int i = 0; i < ui_four; i++)\n' +
                  '    {\n' +
                  '        arr[i] = ${VAR_TYPE}(coords);\n' +
                  '        coords = coords * 0.5;\n' +
                  '    }\n';
        }

        // Read array.
        op += '	${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n';
        if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            op += '    res += arr[0];\n' +
                  '    res += arr[1];\n' +
                  '    res += arr[2];\n' +
                  '    res += arr[3];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            op += '    res += arr[ui_zero];\n' +
                  '    res += arr[ui_one];\n' +
                  '    res += arr[ui_two];\n' +
                  '    res += arr[ui_three];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            op += '    for (int i = 0; i < 4; i++)\n' +
                  '        res += arr[i];\n';
        }
        else {
            assertMsgOptions(readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'readAccess not supported.', false, true);
            op += '    for (int i = 0; i < ui_four; i++)\n' +
                  '        res += arr[i];\n';
        }

        vtx += isVertexCase ? op : '';
        frag += isVertexCase ? '' : op;
        op = '';

        if (isVertexCase) {
            vtx += '    v_color = vec4(res${PADDING});\n';
            frag += '    o_color = v_color;\n';
        }
        else {
            vtx += '    v_coords = a_coords;\n';
            frag += '    o_color = vec4(res${PADDING});\n';
        }

        vtx += '}\n';
        frag += '}\n';

        // Fill in shader templates.
        /** @type {Object} */ var params = {};
    	params["VAR_TYPE"] = gluShaderUtil.getDataTypeName(varType);
    	params["ARRAY_LEN"] = "4";
    	params["PRECISION"] = "mediump";

        if (varType === gluShaderUtil.DataType.FLOAT)
            params['PADDING'] = ', 0.0, 0.0, 1.0';
        else if (varType === gluShaderUtil.DataType.FLOAT_VEC2)
            params['PADDING'] = ', 0.0, 1.0';
        else if (varType === gluShaderUtil.DataType.FLOAT_VEC3)
            params['PADDING'] = ', 1.0';
        else
            params['PADDING'] = '';

    	/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
    	/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);

        /** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
        var evalFunc = es3fShaderIndexingTests.getArrayCoordsEvalFunc(varType);
        return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
    };

    // VECTOR SUBSCRIPT.

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptVec2 = function(c) {
        c.color[0] = c.coords[0] + 0.5 * c.coords[1];
        c.color[1] = c.coords[0] + 0.5 * c.coords[1];
        c.color[2] = c.coords[0] + 0.5 * c.coords[1];
    };
    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptVec3 = function(c) {
        c.color[0] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2];
        c.color[1] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2];
        c.color[2] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2];
    };
    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptVec4 = function(c) {
        c.color[0] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2] + 0.125 * c.coords[3];
        c.color[1] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2] + 0.125 * c.coords[3];
        c.color[2] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2] + 0.125 * c.coords[3];
    };

    /**
     * @param {gluShaderUtil.DataType} dataType
     * @return {function(glsShaderRenderCase.ShaderEvalContext)}
     */
    es3fShaderIndexingTests.getVectorSubscriptEvalFunc = function(dataType) {
        if (dataType === gluShaderUtil.DataType.FLOAT_VEC2) return es3fShaderIndexingTests.evalSubscriptVec2;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC3) return es3fShaderIndexingTests.evalSubscriptVec3;
        else if (dataType === gluShaderUtil.DataType.FLOAT_VEC4) return es3fShaderIndexingTests.evalSubscriptVec4;
        else throw new Error('Invalid data type.');
    };

    /**
     * @param {string} caseName
     * @param {string} description
     * @param {boolean} isVertexCase
     * @param {gluShaderUtil.DataType} varType
     * @param {es3fShaderIndexingTests.VectorAccessType} writeAccess
     * @param {es3fShaderIndexingTests.VectorAccessType} readAccess
     * @return {es3fShaderIndexingTests.ShaderIndexingCase}
     */
    es3fShaderIndexingTests.createVectorSubscriptCase = function(caseName, description, isVertexCase, varType, writeAccess, readAccess) {
        /** @type {string} */ var vtx = '';
        /** @type {string} */ var frag = '';
        /** @type {string} */ var op = '' ;

        /** @type {number} */ var vecLen = gluShaderUtil.getDataTypeScalarSize(varType);
        /** @type {string} */ var vecLenName = glsShaderRenderCase.getIntUniformName(vecLen);

        vtx += '#version 300 es\n';
        frag += '#version 300 es\n';

        vtx += 'in highp vec4 a_position;\n' +
               'in highp vec4 a_coords;\n';
        frag += 'layout(location = 0) out mediump vec4 o_color;\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 (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC ||
            readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC){
            op += 'uniform mediump int ui_zero';
            if (vecLen >= 2) op += ', ui_one';
            if (vecLen >= 3) op += ', ui_two';
            if (vecLen >= 4) op += ', ui_three';
            op += ';\n';
        }

        if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP ||
            readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP)
            op += 'uniform mediump int ' + vecLenName + ';\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';

        // Write vector.
        if (isVertexCase)
            op += '	${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n';
        else
            op += '	${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n';

        op += '	${PRECISION} ${VAR_TYPE} tmp;\n';
        if (writeAccess === es3fShaderIndexingTests.VectorAccessType.DIRECT)
            op += '    tmp = coords.${SWIZZLE} * vec4(1.0, 0.5, 0.25, 0.125).${SWIZZLE};\n';
        else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.COMPONENT) {
            op += '    tmp.x = coords.x;\n';
            if (vecLen >= 2) op += '    tmp.y = coords.y * 0.5;\n';
            if (vecLen >= 3) op += '    tmp.z = coords.z * 0.25;\n';
            if (vecLen >= 4) op += '    tmp.w = coords.w * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC) {
            op += '    tmp[0] = coords.x;\n';
            if (vecLen >= 2) op += '    tmp[1] = coords.y * 0.5;\n';
            if (vecLen >= 3) op += '    tmp[2] = coords.z * 0.25;\n';
            if (vecLen >= 4) op += '    tmp[3] = coords.w * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC) {
            op += '    tmp[ui_zero]  = coords.x;\n';
            if (vecLen >= 2) op += '    tmp[ui_one]   = coords.y * 0.5;\n';
            if (vecLen >= 3) op += '    tmp[ui_two]   = coords.z * 0.25;\n';
            if (vecLen >= 4) op += '    tmp[ui_three] = coords.w * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC_LOOP) {
            op += '    for (int i = 0; i < ' + vecLen + '; i++)\n';
            op += '    {\n';
            op += '        tmp[i] = coords.x;\n';
            op += '        coords = coords.${ROT_SWIZZLE} * 0.5;\n';
            op += '    }\n';
        }
        else {
            assertMsgOptions(writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP, 'writeAccess not supported.', false, true);
            op += '    for (int i = 0; i < ' + vecLenName + '; i++)\n';
            op += '    {\n';
            op += '        tmp[i] = coords.x;\n';
            op += '        coords = coords.${ROT_SWIZZLE} * 0.5;\n';
            op += '    }\n';
        }

        // Read vector.
        op += '	${PRECISION} float res = 0.0;\n';
        if (readAccess === es3fShaderIndexingTests.VectorAccessType.DIRECT)
            op += '	res = dot(tmp, ${VAR_TYPE}(1.0));\n';
        else if (readAccess === es3fShaderIndexingTests.VectorAccessType.COMPONENT) {
            op += '    res += tmp.x;\n';
            if (vecLen >= 2) op += '    res += tmp.y;\n';
            if (vecLen >= 3) op += '    res += tmp.z;\n';
            if (vecLen >= 4) op += '    res += tmp.w;\n';
        }
        else if (readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC) {
            op += '    res += tmp[0];\n';
            if (vecLen >= 2) op += '    res += tmp[1];\n';
            if (vecLen >= 3) op += '    res += tmp[2];\n';
            if (vecLen >= 4) op += '    res += tmp[3];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC) {
            op += '    res += tmp[ui_zero];\n';
            if (vecLen >= 2) op += '    res += tmp[ui_one];\n';
            if (vecLen >= 3) op += '    res += tmp[ui_two];\n';
            if (vecLen >= 4) op += '    res += tmp[ui_three];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC_LOOP) {
            op += '    for (int i = 0; i < ' + vecLen + '; i++)\n';
            op += '        res += tmp[i];\n';
        }
        else {
            assertMsgOptions(readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP, 'readAccess not supported', false, true);
            op += '    for (int i = 0; i < ' + vecLenName + '; i++)\n';
            op += '        res += tmp[i];\n';
        }

        vtx += isVertexCase ? op : '';
        frag += isVertexCase ? '' : op;
        op = '';

        if (isVertexCase) {
            vtx += '    v_color = vec3(res);\n';
            frag += '    o_color = vec4(v_color.rgb, 1.0);\n';
        }
        else {
            vtx += '    v_coords = a_coords;\n';
            frag += '    o_color = vec4(vec3(res), 1.0);\n';
        }

        vtx += '}\n';
        frag += '}\n';

        // Fill in shader templates.
        /** @type {Array<string>} */ var s_swizzles = ['', 'x', 'xy', 'xyz', 'xyzw'];
        /** @type {Array<string>} */ var s_rotSwizzles = ['', 'x', 'yx', 'yzx', 'yzwx'];

        /** @type {Object} */ var params = {};
        params["VAR_TYPE"] = gluShaderUtil.getDataTypeName(varType);
	    params["PRECISION"] = "mediump";
	    params["SWIZZLE"] = s_swizzles[vecLen];
	    params["ROT_SWIZZLE"] = s_rotSwizzles[vecLen];

        /** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
        /** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);

        /** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
        var evalFunc = es3fShaderIndexingTests.getVectorSubscriptEvalFunc(varType);
        return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
    };

    // MATRIX SUBSCRIPT.

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat2 = function(c) {
        var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
        var swizzle12 = deMath.swizzle(c.coords, [1, 2]);
        c.color[0] = swizzle01[0] + 0.5 * swizzle12[0];
        c.color[1] = swizzle01[1] + 0.5 * swizzle12[1];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat2x3 = function(c) {
        var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
        var swizzle123 = deMath.swizzle(c.coords, [1, 2, 3]);
        c.color[0] = swizzle012[0] + 0.5 * swizzle123[0];
        c.color[1] = swizzle012[1] + 0.5 * swizzle123[1];
        c.color[2] = swizzle012[2] + 0.5 * swizzle123[2];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat2x4 = function(c) {
        c.color = deMath.add(
            deMath.swizzle(c.coords, [0,1,2,3]),
            deMath.scale(deMath.swizzle(c.coords, [1,2,3,0]), 0.5));
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat3x2 = function(c) {
        var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
        var swizzle12 = deMath.swizzle(c.coords, [1, 2]);
        var swizzle23 = deMath.swizzle(c.coords, [2, 3]);
        c.color[0] = swizzle01[0] + 0.5 * swizzle12[0] + 0.25 * swizzle23[0];
        c.color[1] = swizzle01[1] + 0.5 * swizzle12[1] + 0.25 * swizzle23[1];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat3 = function(c) {
        var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
        var swizzle123 = deMath.swizzle(c.coords, [1, 2, 3]);
        var swizzle230 = deMath.swizzle(c.coords, [2, 3, 0]);
        c.color[0] = swizzle012[0] + 0.5 * swizzle123[0] + 0.25 * swizzle230[0];
        c.color[1] = swizzle012[1] + 0.5 * swizzle123[1] + 0.25 * swizzle230[1];
        c.color[2] = swizzle012[2] + 0.5 * swizzle123[2] + 0.25 * swizzle230[2];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat3x4 = function(c) {
        var swizzle0123 = deMath.swizzle(c.coords, [0, 1, 2, 3]);
        var swizzle1230 = deMath.swizzle(c.coords, [1, 2, 3, 0]);
        var swizzle2301 = deMath.swizzle(c.coords, [2, 3, 0, 1]);
        c.color = deMath.add(
            swizzle0123,
            deMath.add(
                deMath.scale(swizzle1230, 0.5),
                deMath.scale(swizzle2301, 0.25)));
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat4x2 = function(c) {
        var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
        var swizzle12 = deMath.swizzle(c.coords, [1, 2]);
        var swizzle23 = deMath.swizzle(c.coords, [2, 3]);
        var swizzle30 = deMath.swizzle(c.coords, [3, 0]);
        c.color[0] = swizzle01[0] + 0.5 * swizzle12[0] + 0.25 * swizzle23[0] + 0.125 * swizzle30[0];
        c.color[1] = swizzle01[1] + 0.5 * swizzle12[1] + 0.25 * swizzle23[1] + 0.125 * swizzle30[1];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat4x3 = function(c) {
        var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
        var swizzle123 = deMath.swizzle(c.coords, [1, 2, 3]);
        var swizzle230 = deMath.swizzle(c.coords, [2, 3, 0]);
        var swizzle301 = deMath.swizzle(c.coords, [3, 0, 1]);
        c.color[0] = swizzle012[0] + 0.5 * swizzle123[0] + 0.25 * swizzle230[0] + 0.125 * swizzle301[0];
        c.color[1] = swizzle012[1] + 0.5 * swizzle123[1] + 0.25 * swizzle230[1] + 0.125 * swizzle301[1];
        c.color[2] = swizzle012[2] + 0.5 * swizzle123[2] + 0.25 * swizzle230[2] + 0.125 * swizzle301[2];
    };

    /** @param {glsShaderRenderCase.ShaderEvalContext} c */
    es3fShaderIndexingTests.evalSubscriptMat4 = function(c) {
        var swizzle1230 = deMath.swizzle(c.coords, [1, 2, 3, 0]);
        var swizzle2301 = deMath.swizzle(c.coords, [2, 3, 0, 1]);
        var swizzle3012 = deMath.swizzle(c.coords, [3, 0, 1, 2]);
        c.color = deMath.add(
            c.coords,
            deMath.add(
                deMath.scale(swizzle1230, 0.5),
                deMath.add(
                    deMath.scale(swizzle2301, 0.25),
                    deMath.scale(swizzle3012, 0.125))));
    };

    /**
     * @param  {gluShaderUtil.DataType} dataType
     * @return {function(glsShaderRenderCase.ShaderEvalContext)}
     */
    es3fShaderIndexingTests.getMatrixSubscriptEvalFunc = function(dataType) {
        switch (dataType) {
            case gluShaderUtil.DataType.FLOAT_MAT2: return es3fShaderIndexingTests.evalSubscriptMat2;
            case gluShaderUtil.DataType.FLOAT_MAT2X3: return es3fShaderIndexingTests.evalSubscriptMat2x3;
            case gluShaderUtil.DataType.FLOAT_MAT2X4: return es3fShaderIndexingTests.evalSubscriptMat2x4;
            case gluShaderUtil.DataType.FLOAT_MAT3X2: return es3fShaderIndexingTests.evalSubscriptMat3x2;
            case gluShaderUtil.DataType.FLOAT_MAT3: return es3fShaderIndexingTests.evalSubscriptMat3;
            case gluShaderUtil.DataType.FLOAT_MAT3X4: return es3fShaderIndexingTests.evalSubscriptMat3x4;
            case gluShaderUtil.DataType.FLOAT_MAT4X2: return es3fShaderIndexingTests.evalSubscriptMat4x2;
            case gluShaderUtil.DataType.FLOAT_MAT4X3: return es3fShaderIndexingTests.evalSubscriptMat4x3;
            case gluShaderUtil.DataType.FLOAT_MAT4: return es3fShaderIndexingTests.evalSubscriptMat4;
            default:
                throw new Error('Invalid data type.');
        }
    };

    /**
     * @param {string} caseName
     * @param {string} description
     * @param {boolean} isVertexCase
     * @param {gluShaderUtil.DataType} varType
     * @param {es3fShaderIndexingTests.IndexAccessType} writeAccess
     * @param {es3fShaderIndexingTests.IndexAccessType} readAccess
     * @return {es3fShaderIndexingTests.ShaderIndexingCase}
     */
    es3fShaderIndexingTests.createMatrixSubscriptCase = function(caseName, description, isVertexCase, varType, writeAccess, readAccess) {
        /** @type {string} */ var vtx = '';
        /** @type {string} */ var frag = '';
        /** @type {string} */ var op = '';

        /** @type {number} */ var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(varType);
        /** @type {number} */ var numRows = gluShaderUtil.getDataTypeMatrixNumRows(varType);
        /** @type {string} */ var matSizeName = glsShaderRenderCase.getIntUniformName(numCols);
        /** @type {gluShaderUtil.DataType} */ var vecType = gluShaderUtil.getDataTypeFloatVec(numRows);

        vtx += '#version 300 es\n';
        frag += '#version 300 es\n';

        vtx += 'in highp vec4 a_position;\n' +
               'in highp vec4 a_coords;\n';
        frag += 'layout(location = 0) out mediump vec4 o_color;\n';

        if (isVertexCase) {
            vtx += 'out mediump vec4 v_color;\n';
            frag += 'in mediump vec4 v_color;\n';
        }
        else {
            vtx += 'out mediump vec4 v_coords;\n';
            frag += 'in mediump vec4 v_coords;\n';
        }

        if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            op += 'uniform mediump int ui_zero';
            if (numCols >= 2) op += ', ui_one';
            if (numCols >= 3) op += ', ui_two';
            if (numCols >= 4) op += ', ui_three';
            op += ';\n';
        }

        if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
            op += 'uniform mediump int ' + matSizeName + ';\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';

        // Write matrix.
        if (isVertexCase)
            op += '	${PRECISION} vec4 coords = a_coords;\n';
        else
            op += '	${PRECISION} vec4 coords = v_coords;\n';

        op += '	${PRECISION} ${MAT_TYPE} tmp;\n';
        if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            op += '	tmp[0] = ${VEC_TYPE}(coords);\n';
            if (numCols >= 2) op += '    tmp[1] = ${VEC_TYPE}(coords.yzwx) * 0.5;\n';
            if (numCols >= 3) op += '    tmp[2] = ${VEC_TYPE}(coords.zwxy) * 0.25;\n';
            if (numCols >= 4) op += '    tmp[3] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            op += '	tmp[ui_zero]  = ${VEC_TYPE}(coords);\n';
            if (numCols >= 2) op += '    tmp[ui_one]   = ${VEC_TYPE}(coords.yzwx) * 0.5;\n';
            if (numCols >= 3) op += '    tmp[ui_two]   = ${VEC_TYPE}(coords.zwxy) * 0.25;\n';
            if (numCols >= 4) op += '    tmp[ui_three] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n';
        }
        else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            op += '    for (int i = 0; i < ' + numCols + '; i++)\n';
            op += '    {\n';
            op += '		tmp[i] = ${VEC_TYPE}(coords);\n';
            op += '        coords = coords.yzwx * 0.5;\n';
            op += '    }\n';
        }
        else {
            assertMsgOptions(writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'writeAccess not supported', false, true);
            op += '    for (int i = 0; i < ' + matSizeName + '; i++)\n';
            op += '    {\n';
            op += '        tmp[i] = ${VEC_TYPE}(coords);\n';
            op += '        coords = coords.yzwx * 0.5;\n';
            op += '    }\n';
        }

        // Read matrix.
        op += '	${PRECISION} ${VEC_TYPE} res = ${VEC_TYPE}(0.0);\n';
        if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
            op += '    res += tmp[0];\n';
            if (numCols >= 2) op += '    res += tmp[1];\n';
            if (numCols >= 3) op += '    res += tmp[2];\n';
            if (numCols >= 4) op += '    res += tmp[3];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
            op += '    res += tmp[ui_zero];\n';
            if (numCols >= 2) op += '    res += tmp[ui_one];\n';
            if (numCols >= 3) op += '    res += tmp[ui_two];\n';
            if (numCols >= 4) op += '    res += tmp[ui_three];\n';
        }
        else if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
            op += '    for (int i = 0; i < ' + numCols + '; i++)\n';
            op += '        res += tmp[i];\n';
        }
        else {
            assertMsgOptions(readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'readAccess not supported', false, true);
            op += '    for (int i = 0; i < ' + matSizeName + '; i++)\n';
            op += '        res += tmp[i];\n';
        }

        vtx += isVertexCase ? op : '';
        frag += isVertexCase ? '' : op;
        op = '';

        if (isVertexCase) {
            vtx += '    v_color = vec4(res${PADDING});\n';
            frag += '    o_color = v_color;\n';
        }
        else {
            vtx += '    v_coords = a_coords;\n';
            frag += '    o_color = vec4(res${PADDING});\n';
        }

        vtx += '}\n';
        frag += '}\n';

        // Fill in shader templates.

        /** @type {Object} */ var params = {};
        params['MAT_TYPE'] = gluShaderUtil.getDataTypeName(varType);
        params['VEC_TYPE'] = gluShaderUtil.getDataTypeName(vecType);
        params['PRECISION'] = "mediump";


        if (numRows === 2)
              params['PADDING'] = ', 0.0, 1.0';
        else if (numRows === 3)
              params['PADDING'] = ', 1.0';
        else
              params['PADDING'] = '';

      	/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
      	/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);

        /** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
        var evalFunc = es3fShaderIndexingTests.getMatrixSubscriptEvalFunc(varType);
        return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
    };

    /**
     * @constructor
     * @extends {tcuTestCase.DeqpTest}
     */
    es3fShaderIndexingTests.ShaderIndexingTests = function() {
        tcuTestCase.DeqpTest.call(this, 'indexing', 'Indexing Tests');
    };

    es3fShaderIndexingTests.ShaderIndexingTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
    es3fShaderIndexingTests.ShaderIndexingTests.prototype.constructor = es3fShaderIndexingTests.ShaderIndexingTests;

    es3fShaderIndexingTests.ShaderIndexingTests.prototype.init = function() {
        var testGroup = tcuTestCase.runner.testCases;
        /** @type {Array<gluShaderProgram.shaderType>} */ var s_shaderTypes = [
            gluShaderProgram.shaderType.VERTEX,
            gluShaderProgram.shaderType.FRAGMENT
        ];
        /** @type {Array<gluShaderUtil.DataType>} */ var s_floatAndVecTypes = [
            gluShaderUtil.DataType.FLOAT,
            gluShaderUtil.DataType.FLOAT_VEC2,
            gluShaderUtil.DataType.FLOAT_VEC3,
            gluShaderUtil.DataType.FLOAT_VEC4
        ];
        /** @type {string} */ var name;
        /** @type {string} */ var desc;
        /** @type {string} */ var shaderTypeName;
        /** @type {boolean} */ var isVertexCase;
        /** @type {gluShaderProgram.shaderType} */ var shaderType;
        /** @type {string} */ var writeAccessName;
        /** @type {string} */ var readAccessName;
        // Varying array access cases.
        /** @type {tcuTestCase.DeqpTest} */ var varyingGroup = tcuTestCase.newTest('varying_array', 'Varying array access tests.');
        testGroup.addChild(varyingGroup);
        /** @type {gluShaderUtil.DataType} */ var varType;
        for (var typeNdx = 0; typeNdx < s_floatAndVecTypes.length; typeNdx++) {
            varType = s_floatAndVecTypes[typeNdx];
            for (var vertAccessStr in es3fShaderIndexingTests.IndexAccessType) {
                for (var fragAccessStr in es3fShaderIndexingTests.IndexAccessType) {
                    var vertAccess = es3fShaderIndexingTests.IndexAccessType[vertAccessStr];
                    var fragAccess = es3fShaderIndexingTests.IndexAccessType[fragAccessStr];
                    /** @type {string} */ var vertAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(vertAccess);
                    /** @type {string} */ var fragAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(fragAccess);
                    name = gluShaderUtil.getDataTypeName(varType) + '_' + vertAccessName + '_write_' + fragAccessName + '_read';
                    desc = 'Varying array with ' + vertAccessName + ' write in vertex shader and ' + fragAccessName + ' read in fragment shader.';
                    varyingGroup.addChild(es3fShaderIndexingTests.createVaryingArrayCase(name, desc, varType, vertAccess, fragAccess));
                }
            }
        }

        // Uniform array access cases.
        /** @type {tcuTestCase.DeqpTest} */ var uniformGroup = tcuTestCase.newTest("uniform_array", "Uniform array access tests.");
        testGroup.addChild(uniformGroup);

        for (var typeNdx = 0; typeNdx < s_floatAndVecTypes.length; typeNdx++) {
            varType = s_floatAndVecTypes[typeNdx];
            for (var readAccessStr in es3fShaderIndexingTests.IndexAccessType) {
                var readAccess = es3fShaderIndexingTests.IndexAccessType[readAccessStr];
                readAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(readAccess);
                for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
                    shaderType = s_shaderTypes[shaderTypeNdx];
                    shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
                    name = gluShaderUtil.getDataTypeName(varType) + "_" + readAccessName + "_read_" + shaderTypeName;
                    desc = "Uniform array with " + readAccessName + " read in " + shaderTypeName + " shader.";
                    isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;
                    uniformGroup.addChild(es3fShaderIndexingTests.createUniformArrayCase(name, desc, isVertexCase, varType, readAccess));
                }
            }
        }

        // Temporary array access cases.
        /** @type {tcuTestCase.DeqpTest} */ var tmpGroup = tcuTestCase.newTest("tmp_array", "Temporary array access tests.");
        testGroup.addChild(tmpGroup);

        for (var typeNdx = 0; typeNdx < s_floatAndVecTypes.length; typeNdx++) {
            varType = s_floatAndVecTypes[typeNdx];
            for (var writeAccess in es3fShaderIndexingTests.IndexAccessType) {
                for (var readAccess in es3fShaderIndexingTests.IndexAccessType) {
                    writeAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[writeAccess]);
                    readAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[readAccess]);

                    for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
                        shaderType = s_shaderTypes[shaderTypeNdx];
                        shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
                        name = gluShaderUtil.getDataTypeName(varType) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
                        desc = "Temporary array with " + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
                        isVertexCase = (shaderType === gluShaderProgram.shaderType.VERTEX);
                        tmpGroup.addChild(es3fShaderIndexingTests.createTmpArrayCase(name, desc, isVertexCase, varType, es3fShaderIndexingTests.IndexAccessType[writeAccess], es3fShaderIndexingTests.IndexAccessType[readAccess]));
                    }
                }
            }
        }

        // Vector indexing with subscripts.

        /** @type {Array<gluShaderUtil.DataType>} */ var s_vectorTypes = [
            gluShaderUtil.DataType.FLOAT_VEC2,
            gluShaderUtil.DataType.FLOAT_VEC3,
            gluShaderUtil.DataType.FLOAT_VEC4
        ];

        for (var typeNdx = 0; typeNdx < s_vectorTypes.length; typeNdx++) {
            /** @type {tcuTestCase.DeqpTest} */ var vecGroup = tcuTestCase.newTest("vector_subscript", "Vector subscript indexing.");
            testGroup.addChild(vecGroup);

            varType = s_vectorTypes[typeNdx];
            for (var writeAccess in es3fShaderIndexingTests.VectorAccessType) {
                for (var readAccess in es3fShaderIndexingTests.VectorAccessType) {
                    writeAccessName = es3fShaderIndexingTests.getVectorAccessTypeName(es3fShaderIndexingTests.VectorAccessType[writeAccess]);
                    readAccessName = es3fShaderIndexingTests.getVectorAccessTypeName(es3fShaderIndexingTests.VectorAccessType[readAccess]);

                    for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
                        shaderType = s_shaderTypes[shaderTypeNdx];
                        shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
                        name = gluShaderUtil.getDataTypeName(varType) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
                        desc = "Vector subscript access with " + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
                        isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;
                        vecGroup.addChild(es3fShaderIndexingTests.createVectorSubscriptCase(name, desc, isVertexCase, varType, es3fShaderIndexingTests.VectorAccessType[writeAccess], es3fShaderIndexingTests.VectorAccessType[readAccess]));
                    }
                }
            }
        }

        // Matrix indexing with subscripts.
        /** @type {Array<tcuTestCase.DeqpTest>} */ var matGroup = [
            tcuTestCase.newTest("matrix_subscript", "Matrix subscript indexing."),
            tcuTestCase.newTest("matrix_subscript", "Matrix subscript indexing."),
            tcuTestCase.newTest("matrix_subscript", "Matrix subscript indexing."),
        ];
        for (var ii = 0; ii < matGroup.length; ++ii) {
            testGroup.addChild(matGroup[ii]);
        }

        /** @type {Array<gluShaderUtil.DataType>} */ var s_matrixTypes = [
            gluShaderUtil.DataType.FLOAT_MAT2,
            gluShaderUtil.DataType.FLOAT_MAT2X3,
            gluShaderUtil.DataType.FLOAT_MAT2X4,
            gluShaderUtil.DataType.FLOAT_MAT3X2,
            gluShaderUtil.DataType.FLOAT_MAT3,
            gluShaderUtil.DataType.FLOAT_MAT3X4,
            gluShaderUtil.DataType.FLOAT_MAT4X2,
            gluShaderUtil.DataType.FLOAT_MAT4X3,
            gluShaderUtil.DataType.FLOAT_MAT4
        ];

        for (var typeNdx = 0; typeNdx < s_matrixTypes.length; typeNdx++) {
            varType = s_matrixTypes[typeNdx];
            for (var writeAccess in es3fShaderIndexingTests.IndexAccessType) {
                for (var readAccess in es3fShaderIndexingTests.IndexAccessType) {
                    writeAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[writeAccess]);
                    readAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[readAccess]);

                    for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
                        shaderType = s_shaderTypes[shaderTypeNdx];
                        shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
                        name = gluShaderUtil.getDataTypeName(varType) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
                        desc = "Vector subscript access with " + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
                        isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;
                        matGroup[typeNdx % matGroup.length].addChild(es3fShaderIndexingTests.createMatrixSubscriptCase(
                            name, desc, isVertexCase, varType, es3fShaderIndexingTests.IndexAccessType[writeAccess], es3fShaderIndexingTests.IndexAccessType[readAccess]));
                    }
                }
            }
        }
    };

    /**
     * Run test
     * @param {WebGL2RenderingContext} context
     */
    es3fShaderIndexingTests.run = function(context, range) {
        gl = context;
        //Set up Test Root parameters
        var state = tcuTestCase.runner;
        state.setRoot(new es3fShaderIndexingTests.ShaderIndexingTests());

        //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 es3fShaderIndexingTests.run tests', false);
            tcuTestCase.runner.terminate();
        }
    };

});