[ tor-browser ].git.dasho

es3fTransformFeedbackTests.js (86411B)
      1 /*-------------------------------------------------------------------------
      2 * drawElements Quality Program OpenGL ES Utilities
      3 * ------------------------------------------------
      4 *
      5 * Copyright 2014 The Android Open Source Project
      6 *
      7 * Licensed under the Apache License, Version 2.0 (the "License");
      8 * you may not use this file except in compliance with the License.
      9 * You may obtain a copy of the License at
     10 *
     11 *      http://www.apache.org/licenses/LICENSE-2.0
     12 *
     13 * Unless required by applicable law or agreed to in writing, software
     14 * distributed under the License is distributed on an "AS IS" BASIS,
     15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16 * See the License for the specific language governing permissions and
     17 * limitations under the License.
     18 *
     19 */
     20 
     21 'use strict';
     22 goog.provide('functional.gles3.es3fTransformFeedbackTests');
     23 goog.require('framework.common.tcuImageCompare');
     24 goog.require('framework.common.tcuSurface');
     25 goog.require('framework.common.tcuTestCase');
     26 goog.require('framework.delibs.debase.deMath');
     27 goog.require('framework.delibs.debase.deRandom');
     28 goog.require('framework.delibs.debase.deString');
     29 goog.require('framework.opengl.gluDrawUtil');
     30 goog.require('framework.opengl.gluShaderProgram');
     31 goog.require('framework.opengl.gluShaderUtil');
     32 goog.require('framework.opengl.gluVarType');
     33 goog.require('framework.opengl.gluVarTypeUtil');
     34 
     35 goog.scope(function() {
     36 
     37    var es3fTransformFeedbackTests = functional.gles3.es3fTransformFeedbackTests;
     38    var gluShaderUtil = framework.opengl.gluShaderUtil;
     39    var gluDrawUtil = framework.opengl.gluDrawUtil;
     40    var gluVarType = framework.opengl.gluVarType;
     41    var gluVarTypeUtil = framework.opengl.gluVarTypeUtil;
     42    var gluShaderProgram = framework.opengl.gluShaderProgram;
     43    var deRandom = framework.delibs.debase.deRandom;
     44    var deMath = framework.delibs.debase.deMath;
     45    var deString = framework.delibs.debase.deString;
     46    var tcuTestCase = framework.common.tcuTestCase;
     47    var tcuSurface = framework.common.tcuSurface;
     48    var tcuImageCompare = framework.common.tcuImageCompare;
     49 
     50    /** @type {WebGL2RenderingContext} */ var gl;
     51 
     52    var setParentClass = function(child, parent) {
     53        child.prototype = Object.create(parent.prototype);
     54        child.prototype.constructor = child;
     55    };
     56 
     57    /**
     58     * @enum
     59     */
     60    es3fTransformFeedbackTests.State = {
     61        DRAW: 0,
     62        VERIFY: 1,
     63        FINISH: 2
     64    };
     65 
     66    /* Maximum time to wait for query result (in seconds) */
     67    /** @const */ es3fTransformFeedbackTests.MAX_VERIFY_WAIT = 5;
     68 
     69    /** @const @type {number} */ es3fTransformFeedbackTests.VIEWPORT_WIDTH = 128;
     70    /** @const @type {number} */ es3fTransformFeedbackTests.VIEWPORT_HEIGHT = 128;
     71    /** @const @type {number} */ es3fTransformFeedbackTests.BUFFER_GUARD_MULTIPLIER = 2;
     72 
     73    /**
     74     * Enums for es3fTransformFeedbackTests.interpolation
     75     * @enum {number}
     76     */
     77    es3fTransformFeedbackTests.interpolation = {
     78        SMOOTH: 0,
     79        FLAT: 1,
     80        CENTROID: 2
     81 
     82    };
     83 
     84    /**
     85     * Returns es3fTransformFeedbackTests.interpolation name: smooth, flat or centroid
     86     * @param {number} interpol es3fTransformFeedbackTests.interpolation enum value
     87     * @return {string}
     88     */
     89    es3fTransformFeedbackTests.getInterpolationName = function(interpol) {
     90 
     91        switch (interpol) {
     92        case es3fTransformFeedbackTests.interpolation.SMOOTH: return 'smooth';
     93        case es3fTransformFeedbackTests.interpolation.FLAT: return 'flat';
     94        case es3fTransformFeedbackTests.interpolation.CENTROID: return 'centroid';
     95        default:
     96            throw new Error('Unrecognized es3fTransformFeedbackTests.interpolation name ' + interpol);
     97       }
     98 
     99    };
    100 
    101    /**
    102     * @struct
    103     * @param {string} name
    104     * @param {gluVarType.VarType} type
    105     * @param {number} interpolation
    106     * @constructor
    107     */
    108    es3fTransformFeedbackTests.Varying = function(name, type, interpolation) {
    109        this.name = name;
    110        this.type = type;
    111        this.interpolation = interpolation;
    112    };
    113 
    114    /** es3fTransformFeedbackTests.findAttributeNameEquals
    115     * Replaces original implementation of "VaryingNameEquals" and "AttributeNameEquals" in the C++ version
    116     * Returns an es3fTransformFeedbackTests.Attribute or es3fTransformFeedbackTests.Varying object which matches its name with the passed string value in the function
    117     * @param {(Array<es3fTransformFeedbackTests.Attribute> | Array<es3fTransformFeedbackTests.Varying>)} array
    118     * @param {string} name
    119     * @return { (es3fTransformFeedbackTests.Attribute | es3fTransformFeedbackTests.Varying | null)}
    120     */
    121    es3fTransformFeedbackTests.findAttributeNameEquals = function(array, name) {
    122        for (var pos = 0; pos < array.length; pos++) {
    123            if (array[pos].name === name) {
    124                return array[pos];
    125            }
    126        }
    127        return null;
    128    };
    129 
    130    /**
    131     * @struct
    132     * @param {string} name
    133     * @param {gluVarType.VarType} type
    134     * @param {number} offset
    135     * @constructor
    136     */
    137    es3fTransformFeedbackTests.Attribute = function(name, type, offset) {
    138        this.name = name;
    139        this.type = type;
    140        this.offset = offset;
    141    };
    142 
    143    /**
    144     * Constructs an es3fTransformFeedbackTests.Output object
    145     * @constructor
    146     */
    147    es3fTransformFeedbackTests.Output = function() {
    148        /** @type {number} */ this.bufferNdx = 0;
    149        /** @type {number} */ this.offset = 0;
    150        /** @type {string} */ this.name;
    151        /** @type {gluVarType.VarType} */ this.type = null;
    152        /** @type {Array<es3fTransformFeedbackTests.Attribute>} */ this.inputs = [];
    153    };
    154 
    155    /**
    156     * Constructs an object type es3fTransformFeedbackTests.DrawCall.
    157     * Contains the number of elements as well as whether the Transform Feedback is enabled or not.
    158     * @struct
    159     * @param {number} numElements
    160     * @param {boolean} tfEnabled is Transform Feedback enabled or not
    161     * @constructor
    162     */
    163    es3fTransformFeedbackTests.DrawCall = function(numElements, tfEnabled) {
    164        this.numElements = numElements;
    165        this.transformFeedbackEnabled = tfEnabled;
    166    };
    167 
    168    /**
    169     * @constructor
    170     */
    171    es3fTransformFeedbackTests.ProgramSpec = function() {
    172 
    173    /** @type {Array<gluVarType.StructType>} */ var m_structs = [];
    174    /** @type {Array<es3fTransformFeedbackTests.Varying>} */ var m_varyings = [];
    175    /** @type {Array<string>} */ var m_transformFeedbackVaryings = [];
    176 
    177        this.createStruct = function(name) {
    178            var struct = gluVarType.newStructType(name);
    179            m_structs.push(struct);
    180            return struct;
    181        };
    182 
    183        this.addVarying = function(name, type, interp) {
    184            m_varyings.push(new es3fTransformFeedbackTests.Varying(name, type, interp));
    185        };
    186 
    187        this.addTransformFeedbackVarying = function(name) {
    188            m_transformFeedbackVaryings.push(name);
    189        };
    190 
    191        this.getStructs = function() {
    192            return m_structs;
    193        };
    194        this.getVaryings = function() {
    195            return m_varyings;
    196        };
    197        this.getTransformFeedbackVaryings = function() {
    198            return m_transformFeedbackVaryings;
    199        };
    200 
    201        this.isPointSizeUsed = function() {
    202            for (var i = 0; i < m_transformFeedbackVaryings.length; ++i) {
    203                if (m_transformFeedbackVaryings[i] == 'gl_PointSize') return true;
    204            }
    205            return false;
    206        };
    207 
    208    };
    209 
    210    /** Returns if the program is supported or not
    211     * @param {es3fTransformFeedbackTests.ProgramSpec} spec
    212     * @param {number} tfMode
    213     * @return {boolean}
    214     */
    215    es3fTransformFeedbackTests.isProgramSupported = function(spec, tfMode) {
    216        var maxVertexAttribs = Number(gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
    217        var maxTfInterleavedComponents = Number(gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS));
    218        var maxTfSeparateAttribs = Number(gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS));
    219        var maxTfSeparateComponents = Number(gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS));
    220 
    221        // Check vertex attribs.
    222        /** @type {number} */ var totalVertexAttribs = (
    223            1 /* a_position */ + (spec.isPointSizeUsed() ? 1 : 0)
    224        );
    225 
    226        for (var i = 0; i < spec.getVaryings().length; ++i) {
    227            for (var v_iter = new gluVarTypeUtil.VectorTypeIterator(spec.getVaryings()[i].type); !v_iter.end(); v_iter.next()) {
    228                totalVertexAttribs += 1;
    229            }
    230        }
    231 
    232        if (totalVertexAttribs > maxVertexAttribs)
    233            return false; // Vertex attribute es3fTransformFeedbackTests.count exceeded.
    234 
    235        // check varyings
    236        /** @type {number} */ var totalTfComponents = 0;
    237        /** @type {number} */ var totalTfAttribs = 0;
    238        /** @type {Object.<number, number>} */ var presetNumComponents = {
    239            gl_Position: 4,
    240            gl_PointSize: 1
    241        };
    242        for (var i = 0; i < spec.getTransformFeedbackVaryings().length; ++i) {
    243            var name = spec.getTransformFeedbackVaryings()[i];
    244            var numComponents = 0;
    245 
    246            if (typeof(presetNumComponents[name]) != 'undefined') {
    247                numComponents = presetNumComponents[name];
    248            } else {
    249                var varName = gluVarTypeUtil.parseVariableName(name);
    250                // find the varying called varName
    251                /** @type {es3fTransformFeedbackTests.Varying} */ var varying = (function(varyings) {
    252                    for (var i = 0; i < varyings.length; ++i) {
    253                        if (varyings[i].name == varName) {
    254                            return varyings[i];
    255                        }
    256                    }
    257                    return null;
    258                }(spec.getVaryings()));
    259 
    260                // glu::TypeComponentVector
    261                var varPath = gluVarTypeUtil.parseTypePath(name, varying.type);
    262                numComponents = gluVarTypeUtil.getVarType(varying.type, varPath).getScalarSize();
    263            }
    264 
    265            if (tfMode == gl.SEPARATE_ATTRIBS && numComponents > maxTfSeparateComponents)
    266                return false; // Per-attribute component es3fTransformFeedbackTests.count exceeded.
    267 
    268            totalTfComponents += numComponents;
    269            totalTfAttribs += 1;
    270        }
    271 
    272        if (tfMode == gl.SEPARATE_ATTRIBS && totalTfAttribs > maxTfSeparateAttribs)
    273            return false;
    274 
    275        if (tfMode == gl.INTERLEAVED_ATTRIBS && totalTfComponents > maxTfInterleavedComponents)
    276            return false;
    277 
    278        return true;
    279 
    280    };
    281 
    282    /**
    283     * @param {string} varyingName
    284     * @param {Array<gluVarTypeUtil.VarTypeComponent>} path
    285     * @return {string}
    286     */
    287    es3fTransformFeedbackTests.getAttributeName = function(varyingName, path) {
    288    /** @type {string} */ var str = 'a_' + varyingName.substr(/^v_/.test(varyingName) ? 2 : 0);
    289 
    290        for (var i = 0; i < path.length; ++i) {
    291        /** @type {string} */ var prefix;
    292 
    293            switch (path[i].type) {
    294                case gluVarTypeUtil.VarTypeComponent.s_Type.STRUCT_MEMBER: prefix = '_m'; break;
    295                case gluVarTypeUtil.VarTypeComponent.s_Type.ARRAY_ELEMENT: prefix = '_e'; break;
    296                case gluVarTypeUtil.VarTypeComponent.s_Type.MATRIX_COLUMN: prefix = '_c'; break;
    297                case gluVarTypeUtil.VarTypeComponent.s_Type.VECTOR_COMPONENT: prefix = '_s'; break;
    298                default:
    299                    throw new Error('invalid type in the component path.');
    300            }
    301            str += prefix + path[i].index;
    302        }
    303        return str;
    304    };
    305 
    306    /**
    307     * original definition:
    308     * static void es3fTransformFeedbackTests.genShaderSources (const es3fTransformFeedbackTests.ProgramSpec& spec, std::string& vertSource, std::string& fragSource, bool pointSizeRequired)
    309     * in place of the std::string references, this function returns those params in an object
    310     *
    311     * @param {es3fTransformFeedbackTests.ProgramSpec} spec
    312     * @param {boolean} pointSizeRequired
    313     * @return {Object.<string, string>}
    314     */
    315    es3fTransformFeedbackTests.genShaderSources = function(spec, pointSizeRequired) {
    316 
    317        var vtx = { str: null };
    318        var frag = { str: null };
    319        var addPointSize = spec.isPointSizeUsed();
    320 
    321        vtx.str = '#version 300 es\n' +
    322                 'in highp vec4 a_position;\n';
    323        frag.str = '#version 300 es\n' +
    324                 'layout(location = 0) out mediump vec4 o_color;\n' +
    325                 'uniform highp vec4 u_scale;\n' +
    326                 'uniform highp vec4 u_bias;\n';
    327        //vtx.str = 'attribute highp vec4 a_position;\n';
    328        //frag.str = 'uniform highp vec4 u_scale;\n' +
    329        //         'uniform highp vec4 u_bias;\n';
    330 
    331        if (addPointSize) {
    332            vtx.str += 'in highp float a_pointSize;\n';
    333            //vtx.str += 'attribute highp float a_pointSize;\n';
    334        }
    335 
    336        // Declare attributes.
    337        for (var i = 0; i < spec.getVaryings().length; ++i) {
    338 
    339        /** @type {string} */ var name = spec.getVaryings()[i].name;
    340        /** @type {gluVarType.VarType} */ var type = spec.getVaryings()[i].type;
    341 
    342            for (var vecIter = new gluVarTypeUtil.VectorTypeIterator(type); !vecIter.end(); vecIter.next()) {
    343 
    344                /** @type {gluVarType.VarType} */
    345                var attribType = gluVarTypeUtil.getVarType(type, vecIter.getPath());
    346 
    347                /** @type {string} */
    348                var attribName = es3fTransformFeedbackTests.getAttributeName(name, vecIter.getPath());
    349                vtx.str += 'in ' + gluVarType.declareVariable(attribType, attribName) + ';\n';
    350 
    351            }
    352        }
    353 
    354        // Declare varyings.
    355        for (var ndx = 0; ndx < 2; ++ndx) {
    356            var inout = ndx ? 'in' : 'out';
    357            var shader = ndx ? frag : vtx;
    358 
    359            for (var i = 0; i < spec.getStructs().length; ++i) {
    360                var struct = spec.getStructs()[i];
    361                if (struct.hasTypeName()) {
    362                    shader.str += gluVarType.declareStructType(struct) + ';\n';
    363                }
    364            }
    365 
    366            /** @type {Array<es3fTransformFeedbackTests.Varying>} */ var varyings = spec.getVaryings();
    367            for (var i = 0; i < varyings.length; ++i) {
    368                var varying = varyings[i];
    369                shader.str += es3fTransformFeedbackTests.getInterpolationName(varying.interpolation) +
    370                           ' ' + inout + ' ' +
    371                           gluVarType.declareVariable(varying.type, varying.name) +
    372                           ';\n';
    373            }
    374        }
    375 
    376        vtx.str += '\nvoid main (void)\n {\n' +
    377                 '\tgl_Position = a_position;\n';
    378        frag.str += '\nvoid main (void)\n {\n' +
    379                 '\thighp vec4 res = vec4(0.0);\n';
    380 
    381        if (addPointSize) {
    382            vtx.str += '\tgl_PointSize = a_pointSize;\n';
    383        } else if (pointSizeRequired) {
    384            vtx.str += '\tgl_PointSize = 1.0;\n';
    385        }
    386 
    387        for (var i = 0; i < spec.getVaryings().length; ++i) {
    388            var name = spec.getVaryings()[i].name;
    389            var type = spec.getVaryings()[i].type;
    390 
    391            for (var vecIter = new gluVarTypeUtil.VectorTypeIterator(type); !vecIter.end(); vecIter.next()) {
    392                /** @type {gluVarType.VarType} */var subType = gluVarTypeUtil.getVarType(type, vecIter.getPath());
    393                var attribName = es3fTransformFeedbackTests.getAttributeName(name, vecIter.getPath());
    394 
    395                if (!(
    396                    subType.isBasicType() &&
    397                    gluShaderUtil.isDataTypeScalarOrVector(subType.getBasicType())
    398                )) throw new Error('Not a scalar or vector.');
    399 
    400                // Vertex: assign from attribute.
    401                vtx.str += '\t' + name + vecIter.toString() + ' = ' + attribName + ';\n';
    402 
    403                // Fragment: add to res variable.
    404                var scalarSize = gluShaderUtil.getDataTypeScalarSize(subType.getBasicType());
    405 
    406                frag.str += '\tres += ';
    407                if (scalarSize == 1) frag.str += 'vec4(' + name + vecIter.toString() + ')';
    408                else if (scalarSize == 2) frag.str += 'vec2(' + name + vecIter.toString() + ').xxyy';
    409                else if (scalarSize == 3) frag.str += 'vec3(' + name + vecIter.toString() + ').xyzx';
    410                else if (scalarSize == 4) frag.str += 'vec4(' + name + vecIter.toString() + ')';
    411 
    412                frag.str += ';\n';
    413            }
    414        }
    415 
    416        frag.str += '\to_color = res * u_scale + u_bias;\n}\n';
    417        //frag.str += '\tgl_FragColor = res * u_scale + u_bias;\n}\n';
    418        vtx.str += '}\n';
    419 
    420        return {
    421            vertSource: vtx.str,
    422            fragSource: frag.str
    423        };
    424    };
    425 
    426    /**
    427     * Returns a Shader program
    428     * @param {es3fTransformFeedbackTests.ProgramSpec} spec
    429     * @param {number} bufferMode
    430     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    431     * @return {gluShaderProgram.ShaderProgram}
    432     */
    433    es3fTransformFeedbackTests.createVertexCaptureProgram = function(spec, bufferMode, primitiveType) {
    434 
    435    /** @type {Object.<string, string>} */ var source = es3fTransformFeedbackTests.genShaderSources(spec, primitiveType === gluDrawUtil.primitiveType.POINTS /* Is point size required? */);
    436 
    437        var programSources = new gluShaderProgram.ProgramSources();
    438        programSources.add(new gluShaderProgram.VertexSource(source.vertSource))
    439                      .add(new gluShaderProgram.FragmentSource(source.fragSource))
    440                      .add(new gluShaderProgram.TransformFeedbackVaryings(spec.getTransformFeedbackVaryings()))
    441                      .add(new gluShaderProgram.TransformFeedbackMode(bufferMode));
    442 
    443        return new gluShaderProgram.ShaderProgram(gl, programSources);
    444 
    445    };
    446 
    447    /**
    448     * @param {Array<es3fTransformFeedbackTests.Attribute>} attributes
    449     * @param {Array<es3fTransformFeedbackTests.Varying>} varyings
    450     * @param {boolean} usePointSize
    451     * @return {number} input stride
    452     */
    453    es3fTransformFeedbackTests.computeInputLayout = function(attributes, varyings, usePointSize) {
    454 
    455        var inputStride = 0;
    456 
    457        // Add position
    458        var dataTypeVec4 = gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.precision.PRECISION_HIGHP);
    459        attributes.push(new es3fTransformFeedbackTests.Attribute('a_position', dataTypeVec4, inputStride));
    460        inputStride += 4 * 4; /*sizeof(deUint32)*/
    461 
    462        if (usePointSize) {
    463            var dataTypeFloat = gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT, gluShaderUtil.precision.PRECISION_HIGHP);
    464            attributes.push(new es3fTransformFeedbackTests.Attribute('a_pointSize', dataTypeFloat, inputStride));
    465            inputStride += 1 * 4; /*sizeof(deUint32)*/
    466        }
    467 
    468        for (var i = 0; i < varyings.length; i++) {
    469            for (var vecIter = new gluVarTypeUtil.VectorTypeIterator(varyings[i].type); !vecIter.end(); vecIter.next()) {
    470                var type = vecIter.getType(); // originally getType() in getVarType() within gluVARTypeUtil.hpp.
    471                var name = es3fTransformFeedbackTests.getAttributeName(varyings[i].name, vecIter.getPath());
    472 
    473                attributes.push(new es3fTransformFeedbackTests.Attribute(name, type, inputStride));
    474                inputStride += gluShaderUtil.getDataTypeScalarSize(type.getBasicType()) * 4; /*sizeof(deUint32)*/
    475            }
    476        }
    477 
    478        return inputStride;
    479    };
    480 
    481    /**
    482     * @param {Array<es3fTransformFeedbackTests.Output>} transformFeedbackOutputs
    483     * @param {Array<es3fTransformFeedbackTests.Attribute>} attributes
    484     * @param {Array<es3fTransformFeedbackTests.Varying>} varyings
    485     * @param {Array<string>} transformFeedbackVaryings
    486     * @param {number} bufferMode
    487     */
    488    es3fTransformFeedbackTests.computeTransformFeedbackOutputs = function(transformFeedbackOutputs, attributes, varyings, transformFeedbackVaryings, bufferMode) {
    489 
    490        /** @type {number} */ var accumulatedSize = 0;
    491 
    492        // transformFeedbackOutputs.resize(transformFeedbackVaryings.size());
    493        for (var varNdx = 0; varNdx < transformFeedbackVaryings.length; varNdx++) {
    494            /** @type {string} */ var name = transformFeedbackVaryings[varNdx];
    495            /** @type {number} */ var bufNdx = (bufferMode === gl.SEPARATE_ATTRIBS ? varNdx : 0);
    496            /** @type {number} */ var offset = (bufferMode === gl.SEPARATE_ATTRIBS ? 0 : accumulatedSize);
    497            /** @type {es3fTransformFeedbackTests.Output} */ var output = new es3fTransformFeedbackTests.Output();
    498 
    499            output.name = name;
    500            output.bufferNdx = bufNdx;
    501            output.offset = offset;
    502 
    503            if (name === 'gl_Position') {
    504                var posIn = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_position');
    505                output.type = posIn.type;
    506                output.inputs.push(posIn);
    507            } else if (name === 'gl_PointSize') {
    508                var sizeIn = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_pointSize');
    509                output.type = sizeIn.type;
    510                output.inputs.push(sizeIn);
    511            } else {
    512                var varName = gluVarTypeUtil.parseVariableName(name);
    513                var varying = es3fTransformFeedbackTests.findAttributeNameEquals(varyings, varName);
    514 
    515                var varPath = gluVarTypeUtil.parseTypePath(name, varying.type);
    516                output.type = gluVarTypeUtil.getVarType(varying.type, varPath);
    517 
    518                // Add all vectorized attributes as inputs.
    519                for (var iter = new gluVarTypeUtil.VectorTypeIterator(output.type); !iter.end(); iter.next()) {
    520                    var fullpath = varPath.concat(iter.getPath());
    521                    var attribName = es3fTransformFeedbackTests.getAttributeName(varName, fullpath);
    522                    var attrib = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, attribName);
    523                    output.inputs.push(attrib);
    524                }
    525            }
    526            transformFeedbackOutputs.push(output);
    527            accumulatedSize += output.type.getScalarSize() * 4; /*sizeof(deUint32)*/
    528        }
    529    };
    530 
    531    /**
    532     * @param {es3fTransformFeedbackTests.Attribute} attrib
    533     * @param {ArrayBuffer} buffer
    534     * @param {number} stride
    535     * @param {number} numElements
    536     * @param {deRandom.Random} rnd
    537     */
    538    es3fTransformFeedbackTests.genAttributeData = function(attrib, buffer, stride, numElements, rnd) {
    539 
    540        /** @type {number} */ var elementSize = 4; /*sizeof(deUint32)*/
    541        /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(attrib.type.getBasicType());
    542        /** @type {boolean} */ var isInt = gluShaderUtil.isDataTypeIntOrIVec(attrib.type.getBasicType());
    543        /** @type {boolean} */ var isUint = gluShaderUtil.isDataTypeUintOrUVec(attrib.type.getBasicType());
    544 
    545        /** @type {gluShaderUtil.precision} */ var precision = attrib.type.getPrecision();
    546 
    547        /** @type {number} */ var numComps = gluShaderUtil.getDataTypeScalarSize(attrib.type.getBasicType());
    548 
    549        for (var elemNdx = 0; elemNdx < numElements; elemNdx++) {
    550            for (var compNdx = 0; compNdx < numComps; compNdx++) {
    551                /** @type {number} */ var offset = attrib.offset + elemNdx * stride + compNdx * elementSize;
    552                if (isFloat) {
    553                    var pos = new Float32Array(buffer, offset, 1);
    554                    switch (precision) {
    555                        case gluShaderUtil.precision.PRECISION_LOWP: pos[0] = 0.25 * rnd.getInt(0, 4); break;
    556                        case gluShaderUtil.precision.PRECISION_MEDIUMP: pos[0] = rnd.getFloat(-1e3, 1e3); break;
    557                        case gluShaderUtil.precision.PRECISION_HIGHP: pos[0] = rnd.getFloat(-1e5, 1e5); break;
    558                        default: throw new Error('Unknown precision: ' + precision);
    559                    }
    560                } else if (isInt) {
    561                    var pos = new Int32Array(buffer, offset, 1);
    562                    switch (precision) {
    563                        case gluShaderUtil.precision.PRECISION_LOWP: pos[0] = rnd.getInt(-128, 127); break;
    564                        case gluShaderUtil.precision.PRECISION_MEDIUMP: pos[0] = rnd.getInt(-32768, 32767); break;
    565                        case gluShaderUtil.precision.PRECISION_HIGHP: pos[0] = rnd.getInt(); break;
    566                        default: throw new Error('Unknown precision: ' + precision);
    567                    }
    568                } else if (isUint) {
    569                    var pos = new Uint32Array(buffer, offset, 1);
    570                    switch (precision) {
    571                        case gluShaderUtil.precision.PRECISION_LOWP: pos[0] = rnd.getInt(0, 255); break;
    572                        case gluShaderUtil.precision.PRECISION_MEDIUMP: pos[0] = rnd.getInt(0, 65535); break;
    573                        case gluShaderUtil.precision.PRECISION_HIGHP: pos[0] = Math.abs(rnd.getInt()); break;
    574                        default: throw new Error('Unknown precision: ' + precision);
    575                    }
    576                }
    577            }
    578        }
    579    };
    580 
    581    /**
    582     * @param {Array<es3fTransformFeedbackTests.Attribute>} attributes
    583     * @param {number} numInputs
    584     * @param {number} inputStride
    585     * @param {deRandom.Random} rnd
    586     * @return {ArrayBuffer}
    587     */
    588    es3fTransformFeedbackTests.genInputData = function(attributes, numInputs, inputStride, rnd) {
    589        var buffer = new ArrayBuffer(numInputs * inputStride);
    590 
    591        var position = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_position');
    592        if (!position)
    593            throw new Error('Position attribute not found.');
    594 
    595        for (var ndx = 0; ndx < numInputs; ndx++) {
    596            var pos = new Float32Array(buffer, position.offset + inputStride * ndx, 4);
    597            pos[0] = rnd.getFloat(-1.2, 1.2);
    598            pos[1] = rnd.getFloat(-1.2, 1.2);
    599            pos[2] = rnd.getFloat(-1.2, 1.2);
    600            pos[3] = rnd.getFloat(0.1, 2.0);
    601        }
    602 
    603        var pointSizePos = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_pointSize');
    604        if (pointSizePos) {
    605            for (var ndx = 0; ndx < numInputs; ndx++) {
    606                var pos = new Float32Array(buffer, pointSizePos.offset + inputStride * ndx, 1);
    607                pos[0] = rnd.getFloat(1, 8);
    608            }
    609        }
    610 
    611        // Random data for rest of components.
    612        for (var i = 0; i < attributes.length; i++) {
    613            if (attributes[i].name != 'a_position' && attributes[i].name != 'a_pointSize')
    614                es3fTransformFeedbackTests.genAttributeData(attributes[i], buffer, inputStride, numInputs, rnd);
    615        }
    616 
    617        return buffer;
    618    };
    619 
    620    /**
    621     * Returns the number of outputs with the es3fTransformFeedbackTests.count for the Primitives in the Transform Feedback.
    622     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    623     * @param {number} numElements
    624     * @return {number}
    625     */
    626    es3fTransformFeedbackTests.getTransformFeedbackOutputCount = function(primitiveType, numElements) {
    627 
    628    switch (primitiveType) {
    629        case gluDrawUtil.primitiveType.TRIANGLES: return numElements - numElements % 3;
    630        case gluDrawUtil.primitiveType.TRIANGLE_STRIP: return Math.max(0, numElements - 2) * 3;
    631        case gluDrawUtil.primitiveType.TRIANGLE_FAN: return Math.max(0, numElements - 2) * 3;
    632        case gluDrawUtil.primitiveType.LINES: return numElements - numElements % 2;
    633        case gluDrawUtil.primitiveType.LINE_STRIP: return Math.max(0, numElements - 1) * 2;
    634        case gluDrawUtil.primitiveType.LINE_LOOP: return numElements > 1 ? numElements * 2 : 0;
    635        case gluDrawUtil.primitiveType.POINTS: return numElements;
    636        default:
    637            throw new Error('Unrecognized primitiveType ' + primitiveType);
    638       }
    639 
    640    };
    641 
    642    /**
    643     * Returns a number with the es3fTransformFeedbackTests.count for the Primitives in the Transform Feedback.
    644     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    645     * @param {number} numElements
    646     * @return {number}
    647     */
    648    es3fTransformFeedbackTests.getTransformFeedbackPrimitiveCount = function(primitiveType, numElements) {
    649 
    650    switch (primitiveType) {
    651        case gluDrawUtil.primitiveType.TRIANGLES: return Math.floor(numElements / 3);
    652        case gluDrawUtil.primitiveType.TRIANGLE_STRIP: return Math.max(0, numElements - 2);
    653        case gluDrawUtil.primitiveType.TRIANGLE_FAN: return Math.max(0, numElements - 2);
    654        case gluDrawUtil.primitiveType.LINES: return Math.floor(numElements / 2);
    655        case gluDrawUtil.primitiveType.LINE_STRIP: return Math.max(0, numElements - 1);
    656        case gluDrawUtil.primitiveType.LINE_LOOP: return numElements > 1 ? numElements : 0;
    657        case gluDrawUtil.primitiveType.POINTS: return numElements;
    658        default:
    659            throw new Error('Unrecognized primitiveType ' + primitiveType);
    660       }
    661 
    662    };
    663 
    664    /**
    665     * Returns the type of Primitive Mode: Triangles for all Triangle Primitive's type and same for Line and Points.
    666     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    667     * @return {number} primitiveType
    668     */
    669    es3fTransformFeedbackTests.getTransformFeedbackPrimitiveMode = function(primitiveType) {
    670 
    671    switch (primitiveType) {
    672        case gluDrawUtil.primitiveType.TRIANGLES:
    673        case gluDrawUtil.primitiveType.TRIANGLE_STRIP:
    674        case gluDrawUtil.primitiveType.TRIANGLE_FAN:
    675            return gl.TRIANGLES;
    676 
    677        case gluDrawUtil.primitiveType.LINES:
    678        case gluDrawUtil.primitiveType.LINE_STRIP:
    679        case gluDrawUtil.primitiveType.LINE_LOOP:
    680            return gl.LINES;
    681 
    682        case gluDrawUtil.primitiveType.POINTS:
    683            return gl.POINTS;
    684 
    685        default:
    686            throw new Error('Unrecognized primitiveType ' + primitiveType);
    687       }
    688 
    689    };
    690 
    691    /**
    692     * Returns the attribute index for a certain primitive type.
    693     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    694     * @param {number} numInputs
    695     * @param {number} outNdx
    696     * @return {number}
    697     */
    698    es3fTransformFeedbackTests.getAttributeIndex = function(primitiveType, numInputs, outNdx) {
    699 
    700    switch (primitiveType) {
    701 
    702        case gluDrawUtil.primitiveType.TRIANGLES: return outNdx;
    703        case gluDrawUtil.primitiveType.LINES: return outNdx;
    704        case gluDrawUtil.primitiveType.POINTS: return outNdx;
    705 
    706        case gluDrawUtil.primitiveType.TRIANGLE_STRIP: {
    707            /** @type {number} */ var triNdx = outNdx / 3;
    708            /** @type {number} */ var vtxNdx = outNdx % 3;
    709            return (triNdx % 2 != 0 && vtxNdx < 2) ? (triNdx + 1 - vtxNdx) : (triNdx + vtxNdx);
    710        }
    711 
    712        case gluDrawUtil.primitiveType.TRIANGLE_FAN:
    713            return (outNdx % 3 != 0) ? (outNdx / 3 + outNdx % 3) : 0;
    714 
    715        case gluDrawUtil.primitiveType.LINE_STRIP:
    716            return outNdx / 2 + outNdx % 2;
    717 
    718        case gluDrawUtil.primitiveType.LINE_LOOP: {
    719            var inNdx = outNdx / 2 + outNdx % 2;
    720            return inNdx < numInputs ? inNdx : 0;
    721        }
    722 
    723        default:
    724            throw new Error('Unrecognized primitiveType ' + primitiveType);
    725       }
    726 
    727    };
    728 
    729    /**
    730     * @param {gluDrawUtil.primitiveType} primitiveType type number in gluDrawUtil.primitiveType
    731     * @param {es3fTransformFeedbackTests.Output} output
    732     * @param {number} numInputs
    733     * @param {Object} buffers
    734     * @return {boolean} isOk
    735     */
    736    es3fTransformFeedbackTests.compareTransformFeedbackOutput = function(primitiveType, output, numInputs, buffers) {
    737        /** @type {boolean} */ var isOk = true;
    738        /** @type {number} */ var outOffset = output.offset;
    739 
    740        for (var attrNdx = 0; attrNdx < output.inputs.length; attrNdx++) {
    741        /** @type {es3fTransformFeedbackTests.Attribute} */ var attribute = output.inputs[attrNdx];
    742        /** @type {gluShaderUtil.DataType} */ var type = attribute.type.getBasicType();
    743        /** @type {number} */ var numComponents = gluShaderUtil.getDataTypeScalarSize(type);
    744 
    745        /** @type {gluShaderUtil.precision} */ var precision = attribute.type.getPrecision();
    746 
    747        /** @type {string} */ var scalarType = gluShaderUtil.getDataTypeScalarType(type);
    748        /** @type {number} */ var numOutputs = es3fTransformFeedbackTests.getTransformFeedbackOutputCount(primitiveType, numInputs);
    749 
    750            for (var outNdx = 0; outNdx < numOutputs; outNdx++) {
    751            /** @type {number} */ var inNdx = es3fTransformFeedbackTests.getAttributeIndex(primitiveType, numInputs, outNdx);
    752 
    753                for (var compNdx = 0; compNdx < numComponents; compNdx++) {
    754                /** @type {boolean} */ var isEqual = false;
    755 
    756                    if (scalarType === 'float') {
    757                        var outBuffer = new Float32Array(buffers.output.buffer, buffers.output.offset + buffers.output.stride * outNdx + outOffset + compNdx * 4, 1);
    758                        var inBuffer = new Float32Array(buffers.input.buffer, buffers.input.offset + buffers.input.stride * inNdx + attribute.offset + compNdx * 4, 1);
    759                        var difInOut = inBuffer[0] - outBuffer[0];
    760                        /* TODO: Original code used ULP comparison for highp and mediump precision. This could cause failures. */
    761                        switch (precision) {
    762                            case gluShaderUtil.precision.PRECISION_HIGHP: {
    763                                isEqual = Math.abs(difInOut) < 0.1;
    764                                break;
    765                            }
    766 
    767                            case gluShaderUtil.precision.PRECISION_MEDIUMP: {
    768                                isEqual = Math.abs(difInOut) < 0.1;
    769                                break;
    770                            }
    771 
    772                            case gluShaderUtil.precision.PRECISION_LOWP: {
    773                                isEqual = Math.abs(difInOut) < 0.1;
    774                                break;
    775                            }
    776                            default:
    777                                throw new Error('Unknown precision: ' + precision);
    778                        }
    779                    } else {
    780                        var outBuffer = new Uint32Array(buffers.output.buffer, buffers.output.offset + buffers.output.stride * outNdx + outOffset + compNdx * 4, 1);
    781                        var inBuffer = new Uint32Array(buffers.input.buffer, buffers.input.offset + buffers.input.stride * inNdx + attribute.offset + compNdx * 4, 1);
    782                        isEqual = (inBuffer[0] == outBuffer[0]); // Bit-exact match required for integer types.
    783                    }
    784 
    785                    if (!isEqual) {
    786                        bufferedLogToConsole('Mismatch in ' + output.name + ' (' + attribute.name + '), output = ' + outNdx + ', input = ' + inNdx + ', component = ' + compNdx);
    787                        isOk = false;
    788                        break;
    789                    }
    790                }
    791 
    792                if (!isOk)
    793                    break;
    794            }
    795 
    796            if (!isOk)
    797                break;
    798 
    799            outOffset += numComponents * 4; /*sizeof(deUint32)*/
    800        }
    801 
    802        return isOk;
    803    };
    804 
    805    /**
    806     * Returns (for all the draw calls) the type of Primitive Mode, as it calls "es3fTransformFeedbackTests.getTransformFeedbackPrimitiveCount".
    807     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    808     * @param {Array<es3fTransformFeedbackTests.DrawCall>} array Object.<number, boolean>
    809     * @return {number} primCount
    810     */
    811    es3fTransformFeedbackTests.computeTransformFeedbackPrimitiveCount = function(primitiveType, array) {
    812 
    813    /** @type {number} */ var primCount = 0;
    814 
    815        for (var i = 0; i < array.length; ++ i) {
    816 
    817            if (array[i].transformFeedbackEnabled)
    818                primCount += es3fTransformFeedbackTests.getTransformFeedbackPrimitiveCount(primitiveType, array[i].numElements);
    819        }
    820 
    821        return primCount;
    822    };
    823 
    824    /**
    825     * @param {number} target
    826     * @param {number} bufferSize
    827     * @param {number} guardSize
    828     */
    829    es3fTransformFeedbackTests.writeBufferGuard = function(target, bufferSize, guardSize) {
    830        var buffer = new ArrayBuffer(guardSize);
    831        var view = new Uint8Array(buffer);
    832        for (var i = 0; i < guardSize; ++i) view[i] = 0xcd;
    833        gl.bufferSubData(target, bufferSize, buffer);
    834    };
    835 
    836    /**
    837     * Verifies guard
    838     * @param {ArrayBuffer} buffer
    839     * @param {number} start
    840     * @return {boolean}
    841     */
    842    es3fTransformFeedbackTests.verifyGuard = function(buffer, start) {
    843        start = start || 0;
    844        var view = new Uint8Array(buffer, start);
    845        for (var i = 0; i < view.length; i++) {
    846            if (view[i] != 0xcd)
    847                return false;
    848        }
    849        return true;
    850    };
    851 
    852    /**
    853     * @extends {tcuTestCase.DeqpTest}
    854     * @param {string} name
    855     * @param {string} desc
    856     * @param {number} bufferMode
    857     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
    858     * @constructor
    859     */
    860    es3fTransformFeedbackTests.TransformFeedbackCase = function(name, desc, bufferMode, primitiveType) {
    861        tcuTestCase.DeqpTest.call(this, name, desc);
    862        this.m_bufferMode = bufferMode;
    863        this.m_primitiveType = primitiveType;
    864        this.m_progSpec = new es3fTransformFeedbackTests.ProgramSpec();
    865 
    866        // Derived from es3fTransformFeedbackTests.ProgramSpec in es3fTransformFeedbackTests.init()
    867        this.m_inputStride = 0;
    868        this.m_attributes = []; // vector<es3fTransformFeedbackTests.Attribute>
    869        this.m_transformFeedbackOutputs = []; // vector<es3fTransformFeedbackTests.Output>
    870        this.m_bufferStrides = []; // vector<int>
    871 
    872        // GL state.
    873        this.m_program = null; // glu::ShaderProgram
    874        this.m_transformFeedback = null; // glu::TransformFeedback
    875        this.m_outputBuffers = []; // vector<deUint32>
    876 
    877        this.m_iterNdx = 0; // int
    878        this.m_testPassed = true;
    879        // State machine
    880        this.m_state = es3fTransformFeedbackTests.State.DRAW;
    881        this.m_verifyStart = null;
    882 
    883        this.m_frameWithTf = null;
    884        this.m_frameWithoutTf = null;
    885 
    886        this.m_viewportW = 0;
    887        this.m_viewportH = 0;
    888        this.m_viewportX = 0;
    889        this.m_viewportY = 0;
    890 
    891        this.m_primitiveQuery = null;
    892        this.m_outputsOk = true;
    893 
    894    };
    895 
    896    setParentClass(es3fTransformFeedbackTests.TransformFeedbackCase, tcuTestCase.DeqpTest);
    897 
    898    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.createVerificationResult = function(retry, result) {
    899        return { retry: retry, result: result };
    900    }
    901 
    902    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.dumpShaderText = function() {
    903        var dbgext = gl.getExtension('WEBGL_debug_shaders');
    904        for (var ii = 0; ii < this.m_program.shaders.length; ++ii) {
    905            debug('Shader source ' + ii + ' before translation:')
    906            debug(this.m_program.shaders[ii].info.source);
    907            debug('');
    908            debug('Shader source ' + ii + ' after translation:');
    909            debug(dbgext.getTranslatedShaderSource(this.m_program.shaders[ii].shader));
    910        }
    911    };
    912 
    913    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.init = function() {
    914        this.m_program = es3fTransformFeedbackTests.createVertexCaptureProgram(
    915            this.m_progSpec,
    916            this.m_bufferMode,
    917            this.m_primitiveType
    918        );
    919 
    920        if (!this.m_program.isOk()) {
    921            // this.dumpShaderText();
    922 
    923            var linkFail = this.m_program.shadersOK &&
    924                           !this.m_program.getProgramInfo().linkOk;
    925 
    926            if (linkFail) {
    927                if (!es3fTransformFeedbackTests.isProgramSupported(this.m_progSpec, this.m_bufferMode)) {
    928                    var msg = 'Not Supported. Implementation limits exceeded.';
    929                    checkMessage(false, msg);
    930                    throw new TestFailedException(msg);
    931                } else if (es3fTransformFeedbackTests.hasArraysInTFVaryings(this.m_progSpec)) {
    932                    msg = 'Capturing arrays is not supported (undefined in specification)';
    933                    checkMessage(false, msg);
    934                    throw new TestFailedException(msg);
    935                } else {
    936                    throw new Error('Link failed: ' + this.m_program.getProgramInfo().infoLog);
    937                }
    938            } else {
    939                throw new Error('Compile failed');
    940            }
    941        } else {
    942            // debug('Program is ' +
    943            //       (gl.getProgramParameter(this.m_program.getProgram(), gl.LINK_STATUS) ? 'linked' : 'not linked'));
    944            // this.dumpShaderText();
    945        }
    946 
    947 //          bufferedLogToConsole('Transform feedback varyings: ' + tcu.formatArray(this.m_progSpec.getTransformFeedbackVaryings()));
    948        bufferedLogToConsole('Transform feedback varyings: ' + this.m_progSpec.getTransformFeedbackVaryings());
    949 
    950        // Print out transform feedback points reported by GL.
    951        // bufferedLogToConsole('Transform feedback varyings reported by compiler:');
    952        //logTransformFeedbackVaryings(log, gl, this.m_program.getProgram());
    953 
    954        // Compute input specification.
    955        this.m_inputStride = es3fTransformFeedbackTests.computeInputLayout(this.m_attributes, this.m_progSpec.getVaryings(), this.m_progSpec.isPointSizeUsed());
    956 
    957        // Build list of varyings used in transform feedback.
    958        es3fTransformFeedbackTests.computeTransformFeedbackOutputs(
    959            this.m_transformFeedbackOutputs,
    960            this.m_attributes,
    961            this.m_progSpec.getVaryings(),
    962            this.m_progSpec.getTransformFeedbackVaryings(),
    963            this.m_bufferMode
    964        );
    965        if (!this.m_transformFeedbackOutputs.length) {
    966            throw new Error('transformFeedbackOutputs cannot be empty.');
    967        }
    968 
    969        if (this.m_bufferMode == gl.SEPARATE_ATTRIBS) {
    970            for (var i = 0; i < this.m_transformFeedbackOutputs.length; ++i) {
    971                this.m_bufferStrides.push(this.m_transformFeedbackOutputs[i].type.getScalarSize() * 4 /*sizeof(deUint32)*/);
    972            }
    973        } else {
    974            var totalSize = 0;
    975            for (var i = 0; i < this.m_transformFeedbackOutputs.length; ++i) {
    976                totalSize += this.m_transformFeedbackOutputs[i].type.getScalarSize() * 4 /*sizeof(deUint32)*/;
    977            }
    978            this.m_bufferStrides.push(totalSize);
    979        }
    980 
    981        this.m_outputBuffers.length = this.m_bufferStrides.length;
    982        for (var i = 0; i < this.m_outputBuffers.length; i++)
    983            this.m_outputBuffers[i] = gl.createBuffer();
    984 
    985        this.m_transformFeedback = gl.createTransformFeedback();
    986 
    987        this.m_iterNdx = 0;
    988 //          this.m_testCtx.setTestResult(QP_TEST_RESULT_PASS, 'Pass');
    989 
    990    };
    991 
    992    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.deinit = function() {
    993        for (var i = 0; i < this.m_outputBuffers.length; i++)
    994            gl.deleteBuffer(this.m_outputBuffers[i]);
    995 
    996    //    delete this.m_transformFeedback;
    997        this.m_transformFeedback = null;
    998 
    999    //    delete this.m_program;
   1000        this.m_program = null;
   1001 
   1002        // Clean up state.
   1003        this.m_attributes = [];
   1004        this.m_transformFeedbackOutputs = [];
   1005        this.m_bufferStrides = [];
   1006        this.m_inputStride = 0;
   1007 
   1008    };
   1009 
   1010    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.iterate = function() {
   1011        var s = es3fTransformFeedbackTests.TransformFeedbackCase.s_iterate;
   1012        var numIterations = s.iterations.length;
   1013        var seed = deMath.deMathHash(this.m_iterNdx);
   1014        switch(this.m_state) {
   1015            case es3fTransformFeedbackTests.State.DRAW:
   1016                bufferedLogToConsole('Testing ' +
   1017                    s.testCases[s.iterations[this.m_iterNdx]].length +
   1018                    ' draw calls, (element es3fTransformFeedbackTests.count, TF state): ' +
   1019                    s.testCases[s.iterations[this.m_iterNdx]]
   1020                );
   1021                this.draw(s.testCases[s.iterations[this.m_iterNdx]], seed);
   1022                this.m_state = es3fTransformFeedbackTests.State.VERIFY;
   1023                break;
   1024            case es3fTransformFeedbackTests.State.VERIFY:
   1025                var verifyResult = this.verify(s.testCases[s.iterations[this.m_iterNdx]]);
   1026                if (verifyResult.retry) {
   1027                    break;
   1028                }
   1029                this.m_testPassed = verifyResult.result;
   1030                this.m_iterNdx += 1;
   1031                if (this.m_testPassed && this.m_iterNdx < numIterations) {
   1032                    this.m_state = es3fTransformFeedbackTests.State.DRAW;
   1033                    break;
   1034                }
   1035                // Fall through
   1036            case es3fTransformFeedbackTests.State.FINISH:
   1037                if (!this.m_testPassed) testFailedOptions('Result comparison failed for iteration ' + s.iterations[this.m_iterNdx - 1], false);
   1038                else testPassedOptions('Result comparison succeeded', true);
   1039                return tcuTestCase.IterateResult.STOP;
   1040        }
   1041 
   1042        return tcuTestCase.IterateResult.CONTINUE;
   1043 
   1044    };
   1045 
   1046    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.draw = function(calls, seed) {
   1047        var _min = function(x, y) { return x < y ? x : y; };
   1048 
   1049        var rnd = new deRandom.Random(seed);
   1050        var numInputs = 0;
   1051        var numOutputs = 0;
   1052        var width = gl.drawingBufferWidth;
   1053        var height = gl.drawingBufferHeight;
   1054        this.m_viewportW = _min(es3fTransformFeedbackTests.VIEWPORT_WIDTH, width);
   1055        this.m_viewportH = _min(es3fTransformFeedbackTests.VIEWPORT_HEIGHT, height);
   1056        this.m_viewportX = rnd.getInt(0, width - this.m_viewportW);
   1057        this.m_viewportY = rnd.getInt(0, height - this.m_viewportH);
   1058        this.m_frameWithTf = new tcuSurface.Surface(this.m_viewportW, this.m_viewportH); // tcu::Surface
   1059        this.m_frameWithoutTf = new tcuSurface.Surface(this.m_viewportW, this.m_viewportH); // tcu::Surface
   1060        this.m_primitiveQuery = gl.createQuery();
   1061        this.m_outputsOk = true;
   1062 
   1063        // Compute totals.
   1064        for (var i = 0; i < calls.length; ++i) {
   1065            var call = calls[i];
   1066            numInputs += call.numElements;
   1067            numOutputs += call.transformFeedbackEnabled ? es3fTransformFeedbackTests.getTransformFeedbackOutputCount(this.m_primitiveType, call.numElements) : 0;
   1068        }
   1069 
   1070        // Input data.
   1071        var inputData = es3fTransformFeedbackTests.genInputData(this.m_attributes, numInputs, this.m_inputStride, rnd);
   1072 
   1073        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.m_transformFeedback);
   1074 
   1075        // Allocate storage for transform feedback output buffers and bind to targets.
   1076        for (var bufNdx = 0; bufNdx < this.m_outputBuffers.length; ++bufNdx) {
   1077            var buffer = this.m_outputBuffers[bufNdx]; // deUint32
   1078            var stride = this.m_bufferStrides[bufNdx]; // int
   1079            var target = bufNdx; // int
   1080            var size = stride * numOutputs; // int
   1081            var guardSize = stride * es3fTransformFeedbackTests.BUFFER_GUARD_MULTIPLIER; // int
   1082            var usage = gl.DYNAMIC_READ; // const deUint32
   1083 
   1084            gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer);
   1085            gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, size + guardSize, usage);
   1086            es3fTransformFeedbackTests.writeBufferGuard(gl.TRANSFORM_FEEDBACK_BUFFER, size, guardSize);
   1087 
   1088            // \todo [2012-07-30 pyry] glBindBufferRange()?
   1089            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, target, buffer);
   1090        }
   1091 
   1092        var attribBuffer = gl.createBuffer();
   1093        gl.bindBuffer(gl.ARRAY_BUFFER, attribBuffer);
   1094        gl.bufferData(gl.ARRAY_BUFFER, inputData, gl.STATIC_DRAW);
   1095 
   1096        // Setup attributes.
   1097        for (var i = 0; i < this.m_attributes.length; ++i) {
   1098            var attrib = this.m_attributes[i];
   1099            var loc = gl.getAttribLocation(this.m_program.getProgram(), attrib.name);
   1100            /** @type {string} */
   1101            var scalarType = gluShaderUtil.getDataTypeScalarType(attrib.type.getBasicType());
   1102            /** @type {number} */
   1103            var numComponents = gluShaderUtil.getDataTypeScalarSize(attrib.type.getBasicType());
   1104 
   1105            if (loc >= 0) {
   1106                gl.enableVertexAttribArray(loc);
   1107                switch (scalarType) {
   1108                    case 'float':
   1109                        gl.vertexAttribPointer(loc, numComponents, gl.FLOAT, false, this.m_inputStride, attrib.offset); break;
   1110                    case 'int':
   1111                        gl.vertexAttribIPointer(loc, numComponents, gl.INT, this.m_inputStride, attrib.offset); break;
   1112                    case 'uint':
   1113                        gl.vertexAttribIPointer(loc, numComponents, gl.UNSIGNED_INT, this.m_inputStride, attrib.offset); break;
   1114                }
   1115            }
   1116        }
   1117 
   1118        // Setup viewport.
   1119        gl.viewport(this.m_viewportX, this.m_viewportY, this.m_viewportW, this.m_viewportH);
   1120 
   1121        // Setup program.
   1122        gl.useProgram(this.m_program.getProgram());
   1123 
   1124        gl.uniform4fv(
   1125            gl.getUniformLocation(this.m_program.getProgram(), 'u_scale'),
   1126            [0.01, 0.01, 0.01, 0.01]
   1127        );
   1128        gl.uniform4fv(
   1129            gl.getUniformLocation(this.m_program.getProgram(), 'u_bias'),
   1130            [0.5, 0.5, 0.5, 0.5]
   1131        );
   1132 
   1133        // Enable query.
   1134        gl.beginQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, this.m_primitiveQuery);
   1135 
   1136        // Draw
   1137        var offset = 0;
   1138        var tfEnabled = true;
   1139 
   1140        gl.clear(gl.COLOR_BUFFER_BIT);
   1141 
   1142        var tfPrimitiveMode = es3fTransformFeedbackTests.getTransformFeedbackPrimitiveMode(this.m_primitiveType);
   1143        gl.beginTransformFeedback(tfPrimitiveMode);
   1144 
   1145        for (var i = 0; i < calls.length; ++i) {
   1146            var call = calls[i];
   1147 
   1148            // Pause or resume transform feedback if necessary.
   1149            if (call.transformFeedbackEnabled != tfEnabled) {
   1150                if (call.transformFeedbackEnabled)
   1151                    gl.resumeTransformFeedback();
   1152                else
   1153                    gl.pauseTransformFeedback();
   1154                tfEnabled = call.transformFeedbackEnabled;
   1155            }
   1156 
   1157            gl.drawArrays(gluDrawUtil.getPrimitiveGLType(gl, this.m_primitiveType), offset, call.numElements);
   1158            offset += call.numElements;
   1159        }
   1160 
   1161        // Resume feedback before finishing it.
   1162        if (!tfEnabled)
   1163            gl.resumeTransformFeedback();
   1164 
   1165        gl.endTransformFeedback();
   1166 
   1167        gl.endQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
   1168 
   1169        // Check and log query status right after submit
   1170        var query = this.m_primitiveQuery;
   1171 
   1172        var available = gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
   1173 
   1174        if (available) {
   1175            this.m_testPassed = false;
   1176            this.m_state = es3fTransformFeedbackTests.State.FINISH;
   1177            testFailedOptions('Transform feedback query result must not be available the same frame as they are issued.', true);
   1178        }
   1179 
   1180        // Compare result buffers.
   1181        for (var bufferNdx = 0; bufferNdx < this.m_outputBuffers.length; ++bufferNdx) {
   1182            var stride = this.m_bufferStrides[bufferNdx]; // int
   1183            var size = stride * numOutputs; // int
   1184            var guardSize = stride * es3fTransformFeedbackTests.BUFFER_GUARD_MULTIPLIER; // int
   1185            var buffer = new ArrayBuffer(size + guardSize); // const void*
   1186 
   1187            // Bind buffer for reading.
   1188            gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, this.m_outputBuffers[bufferNdx]);
   1189 
   1190            gl.getBufferSubData(gl.TRANSFORM_FEEDBACK_BUFFER, 0, new Uint8Array(buffer));
   1191 
   1192            // Verify all output variables that are written to this buffer.
   1193            for (var i = 0; i < this.m_transformFeedbackOutputs.length; ++i) {
   1194                var out = this.m_transformFeedbackOutputs[i];
   1195 
   1196                if (out.bufferNdx != bufferNdx)
   1197                    continue;
   1198 
   1199                var inputOffset = 0;
   1200                var outputOffset = 0;
   1201 
   1202                // Process all draw calls and check ones with transform feedback enabled
   1203                for (var callNdx = 0; callNdx < calls.length; ++callNdx) {
   1204                    var call = calls[callNdx];
   1205 
   1206                    if (call.transformFeedbackEnabled) {
   1207                        var inputPtr = inputData[0] + inputOffset * this.m_inputStride; // const deUint8*
   1208                        var outputPtr = outputOffset * stride; // const deUint8*
   1209 
   1210                        if (!es3fTransformFeedbackTests.compareTransformFeedbackOutput(this.m_primitiveType, out, call.numElements, {
   1211                                 input: {
   1212                                    buffer: inputData,
   1213                                    offset: inputOffset * this.m_inputStride,
   1214                                    stride: this.m_inputStride
   1215                                },
   1216                                output: {
   1217                                    buffer: buffer,
   1218                                    offset: outputOffset * stride,
   1219                                    stride: stride
   1220                                }
   1221                            })) {
   1222                            this.m_outputsOk = false;
   1223                            break;
   1224                        }
   1225                    }
   1226 
   1227                    inputOffset += call.numElements;
   1228                    outputOffset += call.transformFeedbackEnabled ? es3fTransformFeedbackTests.getTransformFeedbackOutputCount(this.m_primitiveType, call.numElements) : 0;
   1229                }
   1230            }
   1231 
   1232            // Verify guardband.
   1233            if (!es3fTransformFeedbackTests.verifyGuard(buffer, size)) {
   1234                bufferedLogToConsole('Error: Transform feedback buffer overrun detected');
   1235                this.m_outputsOk = false;
   1236            }
   1237        }
   1238    };
   1239 
   1240    es3fTransformFeedbackTests.TransformFeedbackCase.prototype.verify = function(calls) {
   1241        // Check status after mapping buffers.
   1242        var mustBeReady = this.m_outputBuffers.length > 0; // Mapping buffer forces synchronization. // const bool
   1243        var expectedCount = es3fTransformFeedbackTests.computeTransformFeedbackPrimitiveCount(this.m_primitiveType, calls); // const int
   1244        var available = /** @type {boolean} */ (gl.getQueryParameter(this.m_primitiveQuery, gl.QUERY_RESULT_AVAILABLE));
   1245        var verify_offset = 0;
   1246        var queryOk = true;
   1247        if (!available) {
   1248            if (!this.m_verifyStart)
   1249                this.m_verifyStart = new Date();
   1250            else {
   1251                var current = new Date();
   1252                var elapsedTime = 0.001 * (current.getTime() - this.m_verifyStart.getTime());
   1253                if (elapsedTime > es3fTransformFeedbackTests.MAX_VERIFY_WAIT) {
   1254                    testFailed('Query result not available after ' + elapsedTime + ' seconds.');
   1255                    this.m_state = es3fTransformFeedbackTests.State.FINISH;
   1256                    return this.createVerificationResult(false, false);
   1257                }
   1258            }
   1259            return this.createVerificationResult(true, false);
   1260        }
   1261 
   1262        var numPrimitives = /** @type {number} */ (gl.getQueryParameter(this.m_primitiveQuery, gl.QUERY_RESULT));
   1263 
   1264        if (!mustBeReady && available == false)
   1265            bufferedLogToConsole('ERROR: gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN result not available after mapping buffers!');
   1266 
   1267        bufferedLogToConsole('gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = ' + numPrimitives);
   1268 
   1269        if (numPrimitives != expectedCount) {
   1270            queryOk = false;
   1271            bufferedLogToConsole('ERROR: Expected ' + expectedCount + ' primitives!');
   1272        }
   1273 
   1274        // Clear transform feedback state.
   1275        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
   1276        for (var bufNdx = 0; bufNdx < this.m_outputBuffers.length; ++bufNdx) {
   1277            gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, null);
   1278            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, bufNdx, null);
   1279        }
   1280 
   1281        gl.bindBuffer(gl.ARRAY_BUFFER, null);
   1282 
   1283        // Read back rendered image.
   1284        this.m_frameWithTf.readViewport(gl, [this.m_viewportX, this.m_viewportY, this.m_viewportW, this.m_viewportH]);
   1285 
   1286        // Render without transform feedback.
   1287 
   1288        gl.clear(gl.COLOR_BUFFER_BIT);
   1289 
   1290        for (var i = 0; i < calls.length; ++i) {
   1291            var call = calls[i];
   1292            gl.drawArrays(gluDrawUtil.getPrimitiveGLType(gl, this.m_primitiveType), verify_offset, call.numElements);
   1293            verify_offset += call.numElements;
   1294        }
   1295        this.m_frameWithoutTf.readViewport(gl, [this.m_viewportX, this.m_viewportY, this.m_viewportW, this.m_viewportH]);
   1296 
   1297        // Compare images with and without transform feedback.
   1298        var imagesOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', this.m_frameWithoutTf, this.m_frameWithTf, [1, 1, 1, 1], tcuImageCompare.CompareLogMode.ON_ERROR);
   1299 
   1300        if (imagesOk)
   1301            bufferedLogToConsole('Rendering result comparison between TF enabled and TF disabled passed.');
   1302        else
   1303            bufferedLogToConsole('ERROR: Rendering result comparison between TF enabled and TF disabled failed!');
   1304 
   1305        return this.createVerificationResult(false, this.m_outputsOk && imagesOk && queryOk);
   1306 
   1307    };
   1308 
   1309    es3fTransformFeedbackTests.dc = function(numElements, tfEnabled) {
   1310        return new es3fTransformFeedbackTests.DrawCall(numElements, tfEnabled);
   1311    };
   1312 
   1313    // static data
   1314    es3fTransformFeedbackTests.TransformFeedbackCase.s_iterate = {
   1315 
   1316        testCases: {
   1317            elemCount1: [es3fTransformFeedbackTests.dc(1, true)],
   1318            elemCount2: [es3fTransformFeedbackTests.dc(2, true)],
   1319            elemCount3: [es3fTransformFeedbackTests.dc(3, true)],
   1320            elemCount4: [es3fTransformFeedbackTests.dc(4, true)],
   1321            elemCount123: [es3fTransformFeedbackTests.dc(123, true)],
   1322            basicPause1: [es3fTransformFeedbackTests.dc(64, true), es3fTransformFeedbackTests.dc(64, false), es3fTransformFeedbackTests.dc(64, true)],
   1323            basicPause2: [es3fTransformFeedbackTests.dc(13, true), es3fTransformFeedbackTests.dc(5, true), es3fTransformFeedbackTests.dc(17, false),
   1324                           es3fTransformFeedbackTests.dc(3, true), es3fTransformFeedbackTests.dc(7, false)],
   1325            startPaused: [es3fTransformFeedbackTests.dc(123, false), es3fTransformFeedbackTests.dc(123, true)],
   1326            random1: [es3fTransformFeedbackTests.dc(65, true), es3fTransformFeedbackTests.dc(135, false), es3fTransformFeedbackTests.dc(74, true),
   1327                           es3fTransformFeedbackTests.dc(16, false), es3fTransformFeedbackTests.dc(226, false), es3fTransformFeedbackTests.dc(9, true),
   1328                           es3fTransformFeedbackTests.dc(174, false)],
   1329            random2: [es3fTransformFeedbackTests.dc(217, true), es3fTransformFeedbackTests.dc(171, true), es3fTransformFeedbackTests.dc(147, true),
   1330                           es3fTransformFeedbackTests.dc(152, false), es3fTransformFeedbackTests.dc(55, true)]
   1331        },
   1332        iterations: [
   1333            'elemCount1', 'elemCount2', 'elemCount3', 'elemCount4', 'elemCount123',
   1334            'basicPause1', 'basicPause2', 'startPaused',
   1335            'random1', 'random2'
   1336        ]
   1337    };
   1338 
   1339    es3fTransformFeedbackTests.hasArraysInTFVaryings = function(spec) {
   1340 
   1341        for (var i = 0; i < spec.getTransformFeedbackVaryings().length; ++i) {
   1342            var tfVar = spec.getTransformFeedbackVaryings()[i];
   1343            var varName = gluVarTypeUtil.parseVariableName(tfVar);
   1344 
   1345        var attr = es3fTransformFeedbackTests.findAttributeNameEquals(spec.getVaryings(), varName);
   1346        if (attr && attr.type.isArrayType())
   1347                return true;
   1348        }
   1349        return false;
   1350 
   1351    };
   1352 
   1353    /** es3fTransformFeedbackTests.PositionCase
   1354     * @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
   1355     * @param {string} name
   1356     * @param {string} desc
   1357     * @param {number} bufferMode
   1358     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
   1359     * @constructor
   1360     */
   1361    es3fTransformFeedbackTests.PositionCase = function(name, desc, bufferMode, primitiveType) {
   1362        es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
   1363        this.m_progSpec.addTransformFeedbackVarying('gl_Position');
   1364    };
   1365 
   1366    setParentClass(es3fTransformFeedbackTests.PositionCase, es3fTransformFeedbackTests.TransformFeedbackCase);
   1367 
   1368    /** es3fTransformFeedbackTests.PointSizeCase
   1369     * @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
   1370     * @param {string} name
   1371     * @param {string} desc
   1372     * @param {number} bufferMode
   1373     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
   1374     * @constructor
   1375     */
   1376    es3fTransformFeedbackTests.PointSizeCase = function(name, desc, bufferMode, primitiveType) {
   1377        es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
   1378        this.m_progSpec.addTransformFeedbackVarying('gl_PointSize');
   1379 
   1380    };
   1381 
   1382    setParentClass(es3fTransformFeedbackTests.PointSizeCase, es3fTransformFeedbackTests.TransformFeedbackCase);
   1383 
   1384    /** es3fTransformFeedbackTests.BasicTypeCase
   1385     * @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
   1386     * @param {string} name
   1387     * @param {string} desc
   1388     * @param {number} bufferMode
   1389     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
   1390     * @param {gluShaderUtil.DataType} type
   1391     * @param {gluShaderUtil.precision} precision
   1392     * @param {es3fTransformFeedbackTests.interpolation} interpolation enum number in this javascript
   1393     * @constructor
   1394     */
   1395    es3fTransformFeedbackTests.BasicTypeCase = function(name, desc, bufferMode, primitiveType, type, precision, interpolation) {
   1396        es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
   1397 
   1398        this.m_progSpec.addVarying('v_varA', gluVarType.newTypeBasic(type, precision), interpolation);
   1399        this.m_progSpec.addVarying('v_varB', gluVarType.newTypeBasic(type, precision), interpolation);
   1400 
   1401        this.m_progSpec.addTransformFeedbackVarying('v_varA');
   1402        this.m_progSpec.addTransformFeedbackVarying('v_varB');
   1403 
   1404    };
   1405 
   1406    setParentClass(es3fTransformFeedbackTests.BasicTypeCase, es3fTransformFeedbackTests.TransformFeedbackCase);
   1407 
   1408    /** es3fTransformFeedbackTests.BasicArrayCase
   1409     * @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
   1410     * @param {string} name
   1411     * @param {string} desc
   1412     * @param {number} bufferMode
   1413     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
   1414     * @param {gluShaderUtil.DataType} type
   1415     * @param {gluShaderUtil.precision} precision
   1416     * @param {es3fTransformFeedbackTests.interpolation} interpolation enum number in this javascript
   1417     * @constructor
   1418     */
   1419    es3fTransformFeedbackTests.BasicArrayCase = function(name, desc, bufferMode, primitiveType, type, precision, interpolation) {
   1420        es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
   1421 
   1422        if (gluShaderUtil.isDataTypeMatrix(type) || this.m_bufferMode === gl.SEPARATE_ATTRIBS) {
   1423            // note For matrix types we need to use reduced array sizes or otherwise we will exceed maximum attribute (16)
   1424            // or transform feedback component es3fTransformFeedbackTests.count (64).
   1425            // On separate attribs mode maximum component es3fTransformFeedbackTests.count per varying is 4.
   1426            this.m_progSpec.addVarying('v_varA', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 1), interpolation);
   1427            this.m_progSpec.addVarying('v_varB', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 2), interpolation);
   1428        } else {
   1429            this.m_progSpec.addVarying('v_varA', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 3), interpolation);
   1430            this.m_progSpec.addVarying('v_varB', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 4), interpolation);
   1431        }
   1432 
   1433        this.m_progSpec.addTransformFeedbackVarying('v_varA');
   1434        this.m_progSpec.addTransformFeedbackVarying('v_varB');
   1435 
   1436    };
   1437 
   1438    setParentClass(es3fTransformFeedbackTests.BasicArrayCase, es3fTransformFeedbackTests.TransformFeedbackCase);
   1439 
   1440    /** es3fTransformFeedbackTests.ArrayElementCase
   1441     * @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
   1442     * @param {string} name
   1443     * @param {string} desc
   1444     * @param {number} bufferMode
   1445     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
   1446     * @param {gluShaderUtil.DataType} type
   1447     * @param {gluShaderUtil.precision} precision
   1448     * @param {es3fTransformFeedbackTests.interpolation} interpolation enum number in this javascript
   1449     * @constructor
   1450     */
   1451    es3fTransformFeedbackTests.ArrayElementCase = function(name, desc, bufferMode, primitiveType, type, precision, interpolation) {
   1452 
   1453        es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
   1454 
   1455        this.m_progSpec.addVarying('v_varA', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 3), interpolation);
   1456        this.m_progSpec.addVarying('v_varB', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 4), interpolation);
   1457 
   1458        this.m_progSpec.addTransformFeedbackVarying('v_varA[1]');
   1459        this.m_progSpec.addTransformFeedbackVarying('v_varB[0]');
   1460        this.m_progSpec.addTransformFeedbackVarying('v_varB[3]');
   1461 
   1462    };
   1463 
   1464    setParentClass(es3fTransformFeedbackTests.ArrayElementCase, es3fTransformFeedbackTests.TransformFeedbackCase);
   1465 
   1466    /** es3fTransformFeedbackTests.RandomCase
   1467     * @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
   1468     * @param {string} name
   1469     * @param {string} desc
   1470     * @param {number} bufferMode
   1471     * @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
   1472     * @param {number} seed
   1473     * @constructor
   1474     */
   1475    es3fTransformFeedbackTests.RandomCase = function(name, desc, bufferMode, primitiveType, seed) {
   1476        es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
   1477 
   1478    };
   1479 
   1480    setParentClass(es3fTransformFeedbackTests.RandomCase, es3fTransformFeedbackTests.TransformFeedbackCase);
   1481 
   1482    es3fTransformFeedbackTests.RandomCase.prototype.init = function() {
   1483 
   1484        /** @type {number} */
   1485        var seed = /*deString.deStringHash(getName()) ^ */ deMath.deMathHash(this.m_iterNdx);
   1486 
   1487        /** @type {Array<gluShaderUtil.DataType>} */
   1488        var typeCandidates = [
   1489            gluShaderUtil.DataType.FLOAT,
   1490            gluShaderUtil.DataType.FLOAT_VEC2,
   1491            gluShaderUtil.DataType.FLOAT_VEC3,
   1492            gluShaderUtil.DataType.FLOAT_VEC4,
   1493            gluShaderUtil.DataType.INT,
   1494            gluShaderUtil.DataType.INT_VEC2,
   1495            gluShaderUtil.DataType.INT_VEC3,
   1496            gluShaderUtil.DataType.INT_VEC4,
   1497            gluShaderUtil.DataType.UINT,
   1498            gluShaderUtil.DataType.UINT_VEC2,
   1499            gluShaderUtil.DataType.UINT_VEC3,
   1500            gluShaderUtil.DataType.UINT_VEC4,
   1501 
   1502            gluShaderUtil.DataType.FLOAT_MAT2,
   1503            gluShaderUtil.DataType.FLOAT_MAT2X3,
   1504            gluShaderUtil.DataType.FLOAT_MAT2X4,
   1505 
   1506            gluShaderUtil.DataType.FLOAT_MAT3X2,
   1507            gluShaderUtil.DataType.FLOAT_MAT3,
   1508            gluShaderUtil.DataType.FLOAT_MAT3X4,
   1509 
   1510            gluShaderUtil.DataType.FLOAT_MAT4X2,
   1511            gluShaderUtil.DataType.FLOAT_MAT4X3,
   1512            gluShaderUtil.DataType.FLOAT_MAT4
   1513        ];
   1514 
   1515        /** @type {Array<gluShaderUtil.precision>} */
   1516        var precisions = [
   1517            gluShaderUtil.precision.PRECISION_LOWP,
   1518            gluShaderUtil.precision.PRECISION_MEDIUMP,
   1519            gluShaderUtil.precision.PRECISION_HIGHP
   1520        ];
   1521 
   1522        var interpModes = [{name: 'smooth', interp: es3fTransformFeedbackTests.interpolation.SMOOTH}, {name: 'flat', interp: es3fTransformFeedbackTests.interpolation.FLAT}, {name: 'centroid', interp: es3fTransformFeedbackTests.interpolation.CENTROID}
   1523        ];
   1524 
   1525        /** @type {number} */ var maxAttributeVectors = 16;
   1526       //** @type {number} */  var maxTransformFeedbackComponents = 64; // note It is enough to limit attribute set size.
   1527        /** @type {boolean} */ var isSeparateMode = (this.m_bufferMode === gl.SEPARATE_ATTRIBS);
   1528        /** @type {number} */ var maxTransformFeedbackVars = isSeparateMode ? 4 : maxAttributeVectors;
   1529        /** @type {number} */ var arrayWeight = 0.3;
   1530        /** @type {number} */ var positionWeight = 0.7;
   1531        /** @type {number} */ var pointSizeWeight = 0.1;
   1532        /** @type {number} */ var captureFullArrayWeight = 0.5;
   1533 
   1534        /** @type {deRandom.Random} */
   1535                               var rnd = new deRandom.Random(seed);
   1536        /** @type {boolean} */ var usePosition = rnd.getFloat() < positionWeight;
   1537        /** @type {boolean} */ var usePointSize = rnd.getFloat() < pointSizeWeight;
   1538        /** @type {number} */ var numAttribVectorsToUse = rnd.getInt(
   1539            1, maxAttributeVectors - 1/*position*/ - (usePointSize ? 1 : 0)
   1540        );
   1541 
   1542        /** @type {number} */ var numAttributeVectors = 0;
   1543        /** @type {number} */ var varNdx = 0;
   1544 
   1545        // Generate varyings.
   1546        while (numAttributeVectors < numAttribVectorsToUse) {
   1547            /** @type {number} */
   1548            var maxVecs = isSeparateMode ? Math.min(2 /*at most 2*mat2*/, numAttribVectorsToUse - numAttributeVectors) : numAttribVectorsToUse - numAttributeVectors;
   1549            /** @type {gluShaderUtil.DataType} */
   1550            var begin = typeCandidates[0];
   1551            /** @type {number} */
   1552            var endCandidates = begin + (
   1553                maxVecs >= 4 ? 21 : (
   1554                    maxVecs >= 3 ? 18 : (
   1555                        maxVecs >= 2 ? (isSeparateMode ? 13 : 15) : 12
   1556                    )
   1557                )
   1558            );
   1559            /** @type {gluShaderUtil.DataType} */
   1560            var end = typeCandidates[endCandidates];
   1561 
   1562            /** @type {gluShaderUtil.DataType} */
   1563            var type = rnd.choose(typeCandidates)[0];
   1564 
   1565            /** @type {gluShaderUtil.precision} */
   1566            var precision = rnd.choose(precisions)[0];
   1567 
   1568            /** @type {es3fTransformFeedbackTests.interpolation} */
   1569            var interp = (type === gluShaderUtil.DataType.FLOAT) ?
   1570                       rnd.choose(interpModes)[0].interp :
   1571                       es3fTransformFeedbackTests.interpolation.FLAT;
   1572 
   1573            /** @type {number} */
   1574            var numVecs = gluShaderUtil.isDataTypeMatrix(type) ? gluShaderUtil.getDataTypeMatrixNumColumns(type) : 1;
   1575            /** @type {number} */
   1576            var numComps = gluShaderUtil.getDataTypeScalarSize(type);
   1577            /** @type {number} */
   1578            var maxArrayLen = Math.max(1, isSeparateMode ? (4 / numComps) : (maxVecs / numVecs));
   1579            /** @type {boolean} */
   1580            var useArray = rnd.getFloat() < arrayWeight;
   1581            /** @type {number} */
   1582            var arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 1;
   1583            /** @type {string} */
   1584            var name = 'v_var' + varNdx;
   1585 
   1586            if (useArray)
   1587                this.m_progSpec.addVarying(name, gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), arrayLen), interp);
   1588            else
   1589                this.m_progSpec.addVarying(name, gluVarType.newTypeBasic(type, precision), interp);
   1590 
   1591            numAttributeVectors += arrayLen * numVecs;
   1592            varNdx += 1;
   1593        }
   1594 
   1595        // Generate transform feedback candidate set.
   1596        /** @type {Array<string>} */ var tfCandidates = [];
   1597 
   1598        if (usePosition) tfCandidates.push('gl_Position');
   1599        if (usePointSize) tfCandidates.push('gl_PointSize');
   1600 
   1601        for (var ndx = 0; ndx < varNdx; ndx++) {
   1602            /** @type {es3fTransformFeedbackTests.Varying} */
   1603            var varying = this.m_progSpec.getVaryings()[ndx];
   1604 
   1605            if (varying.type.isArrayType()) {
   1606                /** @type {boolean} */
   1607                var captureFull = rnd.getFloat() < captureFullArrayWeight;
   1608 
   1609                if (captureFull) {
   1610                    tfCandidates.push(varying.name);
   1611                } else {
   1612                    /** @type {number} */
   1613                    var numElem = varying.type.getArraySize();
   1614                    for (var elemNdx = 0; elemNdx < numElem; elemNdx++)
   1615                        tfCandidates.push(varying.name + '[' + elemNdx + ']');
   1616                }
   1617            } else
   1618                tfCandidates.push(varying.name);
   1619        }
   1620 
   1621        // Pick random selection.
   1622        var tfVaryings = [];
   1623        rnd.choose(tfCandidates, tfVaryings, Math.min(tfCandidates.length, maxTransformFeedbackVars));
   1624        rnd.shuffle(tfVaryings);
   1625        for (var i = 0; i < tfVaryings.length; i++)
   1626            this.m_progSpec.addTransformFeedbackVarying(tfVaryings[i]);
   1627 
   1628        es3fTransformFeedbackTests.TransformFeedbackCase.prototype.init.call(this);
   1629 
   1630    };
   1631 
   1632    /**
   1633     * Creates the test in order to be executed
   1634    **/
   1635    es3fTransformFeedbackTests.init = function() {
   1636 
   1637        /** @const @type {tcuTestCase.DeqpTest} */
   1638        var testGroup = tcuTestCase.runner.testCases;
   1639 
   1640        var bufferModes = [{name: 'separate', mode: gl.SEPARATE_ATTRIBS}, {name: 'interleaved', mode: gl.INTERLEAVED_ATTRIBS}
   1641        ];
   1642 
   1643        var primitiveTypes = [{name: 'points', type: gluDrawUtil.primitiveType.POINTS}, {name: 'lines', type: gluDrawUtil.primitiveType.LINES}, {name: 'triangles', type: gluDrawUtil.primitiveType.TRIANGLES}
   1644        ];
   1645 
   1646        /** @type {Array<gluShaderUtil.DataType>} */
   1647        var basicTypes = [
   1648            gluShaderUtil.DataType.FLOAT,
   1649            gluShaderUtil.DataType.FLOAT_VEC2,
   1650            gluShaderUtil.DataType.FLOAT_VEC3,
   1651            gluShaderUtil.DataType.FLOAT_VEC4,
   1652            gluShaderUtil.DataType.FLOAT_MAT2,
   1653            gluShaderUtil.DataType.FLOAT_MAT2X3,
   1654            gluShaderUtil.DataType.FLOAT_MAT2X4,
   1655            gluShaderUtil.DataType.FLOAT_MAT3X2,
   1656            gluShaderUtil.DataType.FLOAT_MAT3,
   1657            gluShaderUtil.DataType.FLOAT_MAT3X4,
   1658            gluShaderUtil.DataType.FLOAT_MAT4X2,
   1659            gluShaderUtil.DataType.FLOAT_MAT4X3,
   1660            gluShaderUtil.DataType.FLOAT_MAT4,
   1661            gluShaderUtil.DataType.INT,
   1662            gluShaderUtil.DataType.INT_VEC2,
   1663            gluShaderUtil.DataType.INT_VEC3,
   1664            gluShaderUtil.DataType.INT_VEC4,
   1665            gluShaderUtil.DataType.UINT,
   1666            gluShaderUtil.DataType.UINT_VEC2,
   1667            gluShaderUtil.DataType.UINT_VEC3,
   1668            gluShaderUtil.DataType.UINT_VEC4
   1669        ];
   1670 
   1671        /** @type {Array<gluShaderUtil.precision>} */
   1672        var precisions = [
   1673 
   1674            gluShaderUtil.precision.PRECISION_LOWP,
   1675            gluShaderUtil.precision.PRECISION_MEDIUMP,
   1676            gluShaderUtil.precision.PRECISION_HIGHP
   1677 
   1678            // glsUBC.UniformFlags.PRECISION_LOW,
   1679            // glsUBC.UniformFlags.PRECISION_MEDIUM,
   1680            // glsUBC.UniformFlags.PRECISION_HIGH
   1681        ];
   1682 
   1683        var interpModes = [{name: 'smooth', interp: es3fTransformFeedbackTests.interpolation.SMOOTH}, {name: 'flat', interp: es3fTransformFeedbackTests.interpolation.FLAT}, {name: 'centroid', interp: es3fTransformFeedbackTests.interpolation.CENTROID}
   1684        ];
   1685 
   1686        // .position
   1687        /** @type {tcuTestCase.DeqpTest} */
   1688        var positionGroup = tcuTestCase.newTest('position', 'gl_Position capture using transform feedback');
   1689        testGroup.addChild(positionGroup);
   1690 
   1691        for (var primitiveType = 0; primitiveType < primitiveTypes.length; primitiveType++) {
   1692            for (var bufferMode = 0; bufferMode < bufferModes.length; bufferMode++) {
   1693                /** @type {string} */
   1694                var name = primitiveTypes[primitiveType].name + '_' + bufferModes[bufferMode].name;
   1695 
   1696                positionGroup.addChild(new es3fTransformFeedbackTests.PositionCase(
   1697                    name,
   1698                    '',
   1699                    bufferModes[bufferMode].mode,
   1700                    primitiveTypes[primitiveType].type
   1701                ));
   1702            }
   1703        }
   1704 
   1705        // .point_size
   1706        /** @type {tcuTestCase.DeqpTest} */ var pointSizeGroup = tcuTestCase.newTest('point_size', 'gl_PointSize capture using transform feedback');
   1707        testGroup.addChild(pointSizeGroup);
   1708 
   1709        for (var primitiveType = 0; primitiveType < primitiveTypes.length; primitiveType++) {
   1710            for (var bufferMode = 0; bufferMode < bufferModes.length; bufferMode++) {
   1711                var name = primitiveTypes[primitiveType].name + '_' + bufferModes[bufferMode].name;
   1712 
   1713                pointSizeGroup.addChild(new es3fTransformFeedbackTests.PointSizeCase(
   1714                    name,
   1715                    '',
   1716                    bufferModes[bufferMode].mode,
   1717                    primitiveTypes[primitiveType].type
   1718                ));
   1719            }
   1720        }
   1721 
   1722        // .basic_type
   1723        for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
   1724            /** @type {number} */
   1725            var bufferMode = bufferModes[bufferModeNdx].mode;
   1726            for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
   1727                /** @type {tcuTestCase.DeqpTest} */
   1728                var primitiveGroup = tcuTestCase.newTest(
   1729                    'basic_types.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
   1730                    'Basic types in transform feedback');
   1731                /** @type {number} */
   1732                var primitiveType = primitiveTypes[primitiveTypeNdx].type;
   1733                testGroup.addChild(primitiveGroup);
   1734 
   1735                for (var typeNdx = 0; typeNdx < basicTypes.length; typeNdx++) {
   1736                    /** @type {gluShaderUtil.DataType} */
   1737                    var type = basicTypes[typeNdx];
   1738                    /** @type {boolean} */
   1739                    var isFloat = gluShaderUtil.getDataTypeScalarType(type) == gluShaderUtil.DataType.FLOAT;
   1740 
   1741                    for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
   1742                        /** @type {gluShaderUtil.precision} */
   1743                        var precision = precisions[precNdx];
   1744                        var name = gluShaderUtil.getPrecisionName(precision) + '_' + gluShaderUtil.getDataTypeName(type);
   1745 
   1746                        primitiveGroup.addChild(new es3fTransformFeedbackTests.BasicTypeCase(
   1747                            name,
   1748                            '',
   1749                            bufferMode,
   1750                            primitiveType,
   1751                            type,
   1752                            precision,
   1753                            isFloat ? es3fTransformFeedbackTests.interpolation.SMOOTH : es3fTransformFeedbackTests.interpolation.FLAT
   1754                        ));
   1755                    }
   1756                }
   1757            }
   1758        }
   1759 
   1760        // .array
   1761        for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
   1762            var bufferMode = bufferModes[bufferModeNdx].mode;
   1763            for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
   1764                var primitiveGroup = tcuTestCase.newTest(
   1765                    'array.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
   1766                    'Capturing whole array in TF');
   1767                /** @type {number} */
   1768                var primitiveType = primitiveTypes[primitiveTypeNdx].type;
   1769                testGroup.addChild(primitiveGroup);
   1770 
   1771                for (var typeNdx = 0; typeNdx < basicTypes.length; typeNdx++) {
   1772                    var type = basicTypes[typeNdx];
   1773                    var isFloat = gluShaderUtil.getDataTypeScalarType(type) == gluShaderUtil.DataType.FLOAT;
   1774 
   1775                    for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
   1776                        var precision = precisions[precNdx];
   1777                        var name = gluShaderUtil.getPrecisionName(precision) + '_' + gluShaderUtil.getDataTypeName(type);
   1778 
   1779                        primitiveGroup.addChild(new es3fTransformFeedbackTests.BasicArrayCase(
   1780                            name,
   1781                            '',
   1782                            bufferMode,
   1783                            primitiveType,
   1784                            type,
   1785                            precision,
   1786                            isFloat ? es3fTransformFeedbackTests.interpolation.SMOOTH : es3fTransformFeedbackTests.interpolation.FLAT
   1787                        ));
   1788                    }
   1789                }
   1790            }
   1791        }
   1792 
   1793        // .array_element
   1794        for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
   1795            var bufferMode = bufferModes[bufferModeNdx].mode;
   1796            for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
   1797                var primitiveGroup = tcuTestCase.newTest(
   1798                    'array_element.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
   1799                    'Capturing single array element in TF');
   1800                var primitiveType = primitiveTypes[primitiveTypeNdx].type;
   1801                testGroup.addChild(primitiveGroup);
   1802 
   1803                for (var typeNdx = 0; typeNdx < basicTypes.length; typeNdx++) {
   1804                    var type = basicTypes[typeNdx];
   1805                    var isFloat = gluShaderUtil.getDataTypeScalarType(type) == gluShaderUtil.DataType.FLOAT;
   1806 
   1807                    for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
   1808                        var precision = precisions[precNdx];
   1809                        var name = gluShaderUtil.getPrecisionName(precision) + '_' + gluShaderUtil.getDataTypeName(type);
   1810 
   1811                        primitiveGroup.addChild(new es3fTransformFeedbackTests.ArrayElementCase(
   1812                            name,
   1813                            '',
   1814                            bufferMode,
   1815                            primitiveType,
   1816                            type,
   1817                            precision,
   1818                            isFloat ? es3fTransformFeedbackTests.interpolation.SMOOTH : es3fTransformFeedbackTests.interpolation.FLAT
   1819                        ));
   1820                    }
   1821                }
   1822            }
   1823        }
   1824 
   1825        // .interpolation
   1826        for (var modeNdx = 0; modeNdx < interpModes.length; modeNdx++) {
   1827            var interp = interpModes[modeNdx].interp;
   1828            var modeGroup = tcuTestCase.newTest(
   1829                'interpolation.' + interpModes[modeNdx].name,
   1830                'Different interpolation modes in transform feedback varyings');
   1831            testGroup.addChild(modeGroup);
   1832 
   1833            for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
   1834                var precision = precisions[precNdx];
   1835 
   1836                for (var primitiveType = 0; primitiveType < primitiveTypes.length; primitiveType++) {
   1837                    for (var bufferMode = 0; bufferMode < bufferModes.length; bufferMode++) {
   1838                        var name = (
   1839                            gluShaderUtil.getPrecisionName(precision) +
   1840                            '_vec4_' + primitiveTypes[primitiveType].name +
   1841                            '_' + bufferModes[bufferMode].name
   1842                        );
   1843 
   1844                        modeGroup.addChild(new es3fTransformFeedbackTests.BasicTypeCase(
   1845                            name,
   1846                            '',
   1847                            bufferModes[bufferMode].mode,
   1848                            primitiveTypes[primitiveType].type,
   1849                            gluShaderUtil.DataType.FLOAT_VEC4,
   1850                            precision,
   1851                            interp
   1852                        ));
   1853                    }
   1854                }
   1855            }
   1856        }
   1857 
   1858        // .random
   1859        for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
   1860            /** @type {number} */
   1861            var bufferMode = bufferModes[bufferModeNdx].mode;
   1862            for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
   1863                var primitiveGroup = tcuTestCase.newTest(
   1864                    'random.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
   1865                    'Randomized transform feedback cases');
   1866                /** @type {number} */
   1867                var primitiveType = primitiveTypes[primitiveTypeNdx].type;
   1868                testGroup.addChild(primitiveGroup);
   1869 
   1870                for (var ndx = 0; ndx < 10; ndx++) {
   1871                    /** @type {number} */
   1872                    var seed = deMath.deMathHash(bufferMode) ^ deMath.deMathHash(primitiveType) ^ deMath.deMathHash(ndx);
   1873 
   1874                    primitiveGroup.addChild(new es3fTransformFeedbackTests.RandomCase(
   1875                        (ndx + 1).toString(),
   1876                        '',
   1877                        bufferMode,
   1878                        primitiveType,
   1879                        seed
   1880                    ));
   1881                }
   1882            }
   1883        }
   1884 
   1885    };
   1886 
   1887    /**
   1888     * Create and execute the test cases
   1889     */
   1890    es3fTransformFeedbackTests.run = function(context, range) {
   1891        gl = context;
   1892        var testName = 'transform_feedback';
   1893        var testDescription = 'Transform Feedback Tests';
   1894        var state = tcuTestCase.runner;
   1895 
   1896        state.testName = testName;
   1897        state.testCases = tcuTestCase.newTest(testName, testDescription, null);
   1898 
   1899        //Set up name and description of this test series.
   1900        setCurrentTestName(testName);
   1901        description(testDescription);
   1902        try {
   1903            es3fTransformFeedbackTests.init();
   1904            if (range)
   1905                state.setRange(range);
   1906            tcuTestCase.runTestCases();
   1907        } catch (err) {
   1908            bufferedLogToConsole(err);
   1909            tcuTestCase.runner.terminate();
   1910        }
   1911 
   1912    };
   1913 
   1914 });
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE