es3fDrawTests.js - mozsearch

mozilla-central/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fDrawTests.js (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: Graphics: CanvasWebGL

Revision control

Copy as Markdown

Other Tools

/*-------------------------------------------------------------------------

 * drawElements Quality Program OpenGL ES Utilities

 * ------------------------------------------------

 * Copyright 2014 The Android Open Source Project

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *      http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

*/

'use strict';

goog.provide('functional.gles3.es3fDrawTests');

goog.require('framework.common.tcuLogImage');

goog.require('framework.common.tcuRGBA');

goog.require('framework.common.tcuSurface');

goog.require('framework.common.tcuTestCase');

goog.require('framework.common.tcuTexture');

goog.require('framework.delibs.debase.deMath');

goog.require('framework.delibs.debase.deRandom');

goog.require('framework.delibs.debase.deString');

goog.require('framework.delibs.debase.deUtil');

goog.require('framework.opengl.gluDrawUtil');

goog.require('framework.opengl.gluShaderProgram');

goog.require('framework.opengl.gluShaderUtil');

goog.require('framework.opengl.gluTexture');

goog.require('framework.opengl.gluVarType');

goog.require('framework.opengl.simplereference.sglrGLContext');

goog.require('framework.opengl.simplereference.sglrShaderProgram');

goog.require('framework.referencerenderer.rrFragmentOperations');

goog.require('framework.referencerenderer.rrGenericVector');

goog.require('framework.referencerenderer.rrShadingContext');

goog.require('framework.referencerenderer.rrVertexAttrib');

goog.require('framework.referencerenderer.rrVertexPacket');

goog.require('modules.shared.glsDrawTests');

goog.scope(function() {

    var es3fDrawTests = functional.gles3.es3fDrawTests;

    var gluDrawUtil = framework.opengl.gluDrawUtil;

    var gluShaderUtil = framework.opengl.gluShaderUtil;

    var gluShaderProgram = framework.opengl.gluShaderProgram;

    var gluTexture = framework.opengl.gluTexture;

    var gluVarType = framework.opengl.gluVarType;

    var tcuLogImage = framework.common.tcuLogImage;

    var tcuRGBA = framework.common.tcuRGBA;

    var tcuTestCase = framework.common.tcuTestCase;

    var tcuSurface = framework.common.tcuSurface;

    var tcuTexture = framework.common.tcuTexture;

    var deMath = framework.delibs.debase.deMath;

    var deString = framework.delibs.debase.deString;

    var deRandom = framework.delibs.debase.deRandom;

    var deUtil = framework.delibs.debase.deUtil;

    var glsDrawTests = modules.shared.glsDrawTests;

    var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram;

    var sglrGLContext = framework.opengl.simplereference.sglrGLContext;

    var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations;

    var rrGenericVector = framework.referencerenderer.rrGenericVector;

    var rrShadingContext = framework.referencerenderer.rrShadingContext;

    var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib;

    var rrVertexPacket = framework.referencerenderer.rrVertexPacket;

    /** @type {WebGL2RenderingContext}*/ var gl;

/**

     * @enum

*/

    es3fDrawTests.TestIterationType = {

        DRAW_COUNT: 0, // !< test with 2, 6, and 26 primitives

        INSTANCE_COUNT: 1, // !< test with 2, 4, and 12 instances

        INDEX_RANGE: 2

};

/**

     * @param {glsDrawTests.DrawTest} test

     * @param {glsDrawTests.DrawTestSpec} baseSpec

     * @param {?es3fDrawTests.TestIterationType} type

*/

    es3fDrawTests.addTestIterations = function(test, baseSpec, type) {

        var spec = /** @type {glsDrawTests.DrawTestSpec} */ (deUtil.clone(baseSpec));

        if (type == es3fDrawTests.TestIterationType.DRAW_COUNT) {

            spec.primitiveCount = 1;

            test.addIteration(spec, 'draw count = ' + spec.primitiveCount);

            spec.primitiveCount = 5;

            test.addIteration(spec, 'draw count = ' + spec.primitiveCount);

            spec.primitiveCount = 25;

            test.addIteration(spec, 'draw count = ' + spec.primitiveCount);

        } else if (type == es3fDrawTests.TestIterationType.INSTANCE_COUNT) {

            spec.instanceCount = 1;

            test.addIteration(spec, 'instance count = ' + spec.instanceCount);

            spec.instanceCount = 4;

            test.addIteration(spec, 'instance count = ' + spec.instanceCount);

            spec.instanceCount = 11;

            test.addIteration(spec, 'instance count = ' + spec.instanceCount);

        } else if (type == es3fDrawTests.TestIterationType.INDEX_RANGE) {

            spec.indexMin = 0;

            spec.indexMax = 23;

            test.addIteration(spec, 'index range = [' + spec.indexMin + ', ' + spec.indexMax + ']');

            spec.indexMin = 23;

            spec.indexMax = 40;

            test.addIteration(spec, 'index range = [' + spec.indexMin + ', ' + spec.indexMax + ']');

            // Only makes sense with points

            if (spec.primitive == glsDrawTests.DrawTestSpec.Primitive.POINTS) {

                spec.indexMin = 5;

                spec.indexMax = 5;

                test.addIteration(spec, 'index range = [' + spec.indexMin + ', ' + spec.indexMax + ']');

        } else

            throw new Error('Invalid test iteration type');

};

/**

     * @param {glsDrawTests.DrawTestSpec} spec

     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} method

*/

    es3fDrawTests.genBasicSpec = function(spec, method) {

        //spec.apiType = glu::ApiType::es(3,0);

        spec.primitive = glsDrawTests.DrawTestSpec.Primitive.TRIANGLES;

        spec.primitiveCount = 6;

        spec.drawMethod = method;

        spec.indexType = null;

        spec.indexPointerOffset = 0;

        spec.indexStorage = null;

        spec.first = 0;

        spec.indexMin = 0;

        spec.indexMax = 0;

        spec.instanceCount = 1;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[0].componentCount = 4;

        spec.attribs[0].offset = 0;

        spec.attribs[0].stride = 0;

        spec.attribs[0].normalize = false;

        spec.attribs[0].instanceDivisor = 0;

        spec.attribs[0].useDefaultAttribute = false;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[1].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[1].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[1].componentCount = 2;

        spec.attribs[1].offset = 0;

        spec.attribs[1].stride = 0;

        spec.attribs[1].normalize = false;

        spec.attribs[1].instanceDivisor = 0;

        spec.attribs[1].useDefaultAttribute = false;

};

/**

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

     * @param {string} name

     * @param {string} descr

     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod

     * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive

     * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType

     * @param {?glsDrawTests.DrawTestSpec.Storage} indexStorage

*/

    es3fDrawTests.AttributeGroup = function(name, descr, drawMethod, primitive, indexType, indexStorage) {

        tcuTestCase.DeqpTest.call(this, name, descr);

        this.m_method = drawMethod;

        this.m_primitive = primitive;

        this.m_indexType = indexType;

        this.m_indexStorage = indexStorage;

        this.makeExecutable();

};

    es3fDrawTests.AttributeGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.AttributeGroup.prototype.constructor = es3fDrawTests.AttributeGroup;

    es3fDrawTests.AttributeGroup.prototype.init = function() {

        // select test type

        /** @type {boolean} */ var instanced = this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED ||

            this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED;

        /** @type {boolean} */ var ranged = this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED;

        /** @type {es3fDrawTests.TestIterationType} */ var testType = instanced ? es3fDrawTests.TestIterationType.INSTANCE_COUNT :

            (ranged ? es3fDrawTests.TestIterationType.INDEX_RANGE : es3fDrawTests.TestIterationType.DRAW_COUNT);

        // Single attribute

        /** @type {glsDrawTests.DrawTest} */ var test = new glsDrawTests.DrawTest(null, 'single_attribute', 'Single attribute array.');

        /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec();

        //spec.apiType = glu::ApiType::es(3,0);

        spec.primitive = this.m_primitive;

        spec.primitiveCount = 5;

        spec.drawMethod = this.m_method;

        spec.indexType = this.m_indexType;

        spec.indexPointerOffset = 0;

        spec.indexStorage = this.m_indexStorage;

        spec.first = 0;

        spec.indexMin = 0;

        spec.indexMax = 0;

        spec.instanceCount = 1;

        spec.attribs.length = 0;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[0].componentCount = 2;

        spec.attribs[0].offset = 0;

        spec.attribs[0].stride = 0;

        spec.attribs[0].normalize = false;

        spec.attribs[0].instanceDivisor = 0;

        spec.attribs[0].useDefaultAttribute = false;

        es3fDrawTests.addTestIterations(test, spec, testType);

        this.addChild(test);

        // Multiple attribute

        test = new glsDrawTests.DrawTest(null, 'multiple_attributes', 'Multiple attribute arrays.');

        spec.primitive = this.m_primitive;

        spec.primitiveCount = 5;

        spec.drawMethod = this.m_method;

        spec.indexType = this.m_indexType;

        spec.indexPointerOffset = 0;

        spec.indexStorage = this.m_indexStorage;

        spec.first = 0;

        spec.indexMin = 0;

        spec.indexMax = 0;

        spec.instanceCount = 1;

        spec.attribs.length = 0;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[0].componentCount = 4;

        spec.attribs[0].offset = 0;

        spec.attribs[0].stride = 0;

        spec.attribs[0].normalize = false;

        spec.attribs[0].instanceDivisor = 0;

        spec.attribs[0].useDefaultAttribute = false;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[1].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[1].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[1].componentCount = 2;

        spec.attribs[1].offset = 0;

        spec.attribs[1].stride = 0;

        spec.attribs[1].normalize = false;

        spec.attribs[1].instanceDivisor = 0;

        spec.attribs[1].useDefaultAttribute = false;

        es3fDrawTests.addTestIterations(test, spec, testType);

        this.addChild(test);

        // Multiple attribute, second one divided

        test = new glsDrawTests.DrawTest(null, 'instanced_attributes', 'Instanced attribute array.');

        //spec.apiType = glu::ApiType::es(3,0);

        spec.primitive = this.m_primitive;

        spec.primitiveCount = 5;

        spec.drawMethod = this.m_method;

        spec.indexType = this.m_indexType;

        spec.indexPointerOffset = 0;

        spec.indexStorage = this.m_indexStorage;

        spec.first = 0;

        spec.indexMin = 0;

        spec.indexMax = 0;

        spec.instanceCount = 1;

        spec.attribs.length = 0;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[0].componentCount = 4;

        spec.attribs[0].offset = 0;

        spec.attribs[0].stride = 0;

        spec.attribs[0].normalize = false;

        spec.attribs[0].instanceDivisor = 0;

        spec.attribs[0].useDefaultAttribute = false;

        // Add another position component so the instances wont be drawn on each other

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[1].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[1].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[1].componentCount = 2;

        spec.attribs[1].offset = 0;

        spec.attribs[1].stride = 0;

        spec.attribs[1].normalize = false;

        spec.attribs[1].instanceDivisor = 1;

        spec.attribs[1].useDefaultAttribute = false;

        spec.attribs[1].additionalPositionAttribute = true;

        // Instanced color

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[2].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[2].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[2].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[2].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[2].componentCount = 3;

        spec.attribs[2].offset = 0;

        spec.attribs[2].stride = 0;

        spec.attribs[2].normalize = false;

        spec.attribs[2].instanceDivisor = 1;

        spec.attribs[2].useDefaultAttribute = false;

        es3fDrawTests.addTestIterations(test, spec, testType);

        this.addChild(test);

        // Multiple attribute, second one default

        test = new glsDrawTests.DrawTest(null, 'default_attribute', 'Attribute specified with glVertexAttrib*.');

        //spec.apiType = glu::ApiType::es(3,0);

        spec.primitive = this.m_primitive;

        spec.primitiveCount = 5;

        spec.drawMethod = this.m_method;

        spec.indexType = this.m_indexType;

        spec.indexPointerOffset = 0;

        spec.indexStorage = this.m_indexStorage;

        spec.first = 0;

        spec.indexMin = 0;

        spec.indexMax = 17; // \note addTestIterations is not called for the spec, so we must ensure [indexMin, indexMax] is a good range

        spec.instanceCount = 1;

        spec.attribs.length = 0;

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT;

        spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2;

        spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

        spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

        spec.attribs[0].componentCount = 2;

        spec.attribs[0].offset = 0;

        spec.attribs[0].stride = 0;

        spec.attribs[0].normalize = false;

        spec.attribs[0].instanceDivisor = 0;

        spec.attribs[0].useDefaultAttribute = false;

        /** @type {Array<{input:?glsDrawTests.DrawTestSpec.InputType, output:?glsDrawTests.DrawTestSpec.OutputType, componentCount:number}>} */ var iopairs = [

            {input: glsDrawTests.DrawTestSpec.InputType.FLOAT, output: glsDrawTests.DrawTestSpec.OutputType.VEC2, componentCount: 4},

            {input: glsDrawTests.DrawTestSpec.InputType.FLOAT, output: glsDrawTests.DrawTestSpec.OutputType.VEC4, componentCount: 2},

            {input: glsDrawTests.DrawTestSpec.InputType.INT, output: glsDrawTests.DrawTestSpec.OutputType.IVEC3, componentCount: 4},

            {input: glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT, output: glsDrawTests.DrawTestSpec.OutputType.UVEC2, componentCount: 4}

];

        spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec());

        for (var ioNdx = 0; ioNdx < iopairs.length; ++ioNdx) {

            /** @type {string} */ var desc = glsDrawTests.DrawTestSpec.inputTypeToString(iopairs[ioNdx].input) + iopairs[ioNdx].componentCount + ' to ' + glsDrawTests.DrawTestSpec.outputTypeToString(iopairs[ioNdx].output);

            spec.attribs[1].inputType = iopairs[ioNdx].input;

            spec.attribs[1].outputType = iopairs[ioNdx].output;

            spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER;

            spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW;

            spec.attribs[1].componentCount = iopairs[ioNdx].componentCount;

            spec.attribs[1].offset = 0;

            spec.attribs[1].stride = 0;

            spec.attribs[1].normalize = false;

            spec.attribs[1].instanceDivisor = 0;

            spec.attribs[1].useDefaultAttribute = true;

            test.addIteration(spec, desc);

        this.addChild(test);

};

/**

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

     * @param {string} name

     * @param {string} descr

     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod

*/

    es3fDrawTests.IndexGroup = function(name, descr, drawMethod) {

        tcuTestCase.DeqpTest.call(this, name, descr);

        /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.m_method = drawMethod;

        this.makeExecutable();

};

    es3fDrawTests.IndexGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.IndexGroup.prototype.constructor = es3fDrawTests.IndexGroup;

    es3fDrawTests.IndexGroup.prototype.init = function() {

        /** @type {Array<{storage: ?glsDrawTests.DrawTestSpec.Storage, type: ?glsDrawTests.DrawTestSpec.IndexType, aligned: boolean, offsets: Array<number>}>} */ var tests = [

            {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.BYTE, aligned: true, offsets: [0, 1, -1]},

            {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.SHORT, aligned: true, offsets: [0, 2, -1]},

            {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.INT, aligned: true, offsets: [0, 4, -1]},

            {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.SHORT, aligned: false, offsets: [1, 3, -1]},

            {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.INT, aligned: false, offsets: [2, 3, -1]}

];

        /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec();

        es3fDrawTests.genBasicSpec(spec, this.m_method);

        /** @type {tcuTestCase.DeqpTest} */ var bufferGroup = new tcuTestCase.DeqpTest('buffer', 'buffer');

        /** @type {tcuTestCase.DeqpTest} */ var unalignedBufferGroup = new tcuTestCase.DeqpTest('unaligned_buffer', 'unaligned buffer');

        this.addChild(bufferGroup);

        this.addChild(unalignedBufferGroup);

        for (var testNdx = 0; testNdx < tests.length; ++testNdx) {

            /** @type {{storage: ?glsDrawTests.DrawTestSpec.Storage, type: ?glsDrawTests.DrawTestSpec.IndexType, aligned: boolean, offsets: Array<number>}} */

            var indexTest = tests[testNdx];

            /** @type {tcuTestCase.DeqpTest} */ var group = indexTest.aligned ? bufferGroup : unalignedBufferGroup;

            /** @type {string} */ var name = 'index_' + glsDrawTests.DrawTestSpec.indexTypeToString(indexTest.type);

            /** @type {string} */ var desc = 'index ' + glsDrawTests.DrawTestSpec.indexTypeToString(indexTest.type) + ' in ' + glsDrawTests.DrawTestSpec.storageToString(indexTest.storage);

            /** @type {glsDrawTests.DrawTest} */ var test = new glsDrawTests.DrawTest(null, name, desc);

            spec.indexType = indexTest.type;

            spec.indexStorage = indexTest.storage;

            for (var iterationNdx = 0; iterationNdx < indexTest.offsets.length && indexTest.offsets[iterationNdx] != -1; ++iterationNdx) {

                /** @type {string} */ var iterationDesc = 'offset ' + indexTest.offsets[iterationNdx];

                spec.indexPointerOffset = indexTest.offsets[iterationNdx];

                test.addIteration(spec, iterationDesc);

            if (spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET &&

                spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE)

                group.addChild(test);

};

/**

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

     * @param {string} name

     * @param {string} descr

     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod

*/

    es3fDrawTests.FirstGroup = function(name, descr, drawMethod) {

        tcuTestCase.DeqpTest.call(this, name, descr);

        /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.m_method = drawMethod;

        this.makeExecutable();

};

    es3fDrawTests.FirstGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.FirstGroup.prototype.constructor = es3fDrawTests.FirstGroup;

/**

     * init

*/

    es3fDrawTests.FirstGroup.prototype.init = function() {

        var firsts =

            1, 3, 17

];

        /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec();

        es3fDrawTests.genBasicSpec(spec, this.m_method);

        for (var firstNdx = 0; firstNdx < firsts.length; ++firstNdx) {

            var name = 'first_' + firsts[firstNdx];

            var desc = 'first ' + firsts[firstNdx];

            /** @type {glsDrawTests.DrawTest} */ var test = new glsDrawTests.DrawTest(null, name, desc);

            spec.first = firsts[firstNdx];

            es3fDrawTests.addTestIterations(test, spec, es3fDrawTests.TestIterationType.DRAW_COUNT);

            this.addChild(test);

};

/**

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

     * @param {string} name

     * @param {string} descr

     * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod

*/

    es3fDrawTests.MethodGroup = function(name, descr, drawMethod) {

        tcuTestCase.DeqpTest.call(this, name, descr);

        /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.m_method = drawMethod;

        this.makeExecutable();

};

    es3fDrawTests.MethodGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.MethodGroup.prototype.constructor = es3fDrawTests.MethodGroup;

/**

     * init

*/

    es3fDrawTests.MethodGroup.prototype.init = function() {

        var indexed = (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) || (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) || (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED);

        var hasFirst = (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) || (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED);

        var primitive =

            glsDrawTests.DrawTestSpec.Primitive.POINTS,

            glsDrawTests.DrawTestSpec.Primitive.TRIANGLES,

            glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN,

            glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP,

            glsDrawTests.DrawTestSpec.Primitive.LINES,

            glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP,

            glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP

];

        if (hasFirst) {

            // First-tests

            this.addChild(new es3fDrawTests.FirstGroup('first', 'First tests', this.m_method));

        if (indexed) {

            // Index-tests

            if (this.m_method != glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED)

                this.addChild(new es3fDrawTests.IndexGroup('indices', 'Index tests', this.m_method));

        for (var ndx = 0; ndx < primitive.length; ++ndx) {

            var name = glsDrawTests.DrawTestSpec.primitiveToString(primitive[ndx]);

            var desc = glsDrawTests.DrawTestSpec.primitiveToString(primitive[ndx]);

            this.addChild(new es3fDrawTests.AttributeGroup(name, desc, this.m_method, primitive[ndx], glsDrawTests.DrawTestSpec.IndexType.SHORT, glsDrawTests.DrawTestSpec.Storage.BUFFER));

};

/**

     * es3fDrawTests.GridProgram

     * @constructor

     * @extends {sglrShaderProgram.ShaderProgram}

*/

    es3fDrawTests.GridProgram = function() {

        /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var decl = new sglrShaderProgram.ShaderProgramDeclaration();

        decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT));

        decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_offset', rrGenericVector.GenericVecType.FLOAT));

        decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_color', rrGenericVector.GenericVecType.FLOAT));

        decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT));

        decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));

        decl.pushVertexSource(new sglrShaderProgram.VertexSource(

            '#version 300 es\n' +

            'in highp vec4 a_position;\n' +

            'in highp vec4 a_offset;\n' +

            'in highp vec4 a_color;\n' +

            'out mediump vec4 v_color;\n' +

            'void main(void)\n' +

            '{\n' +

            ' gl_Position = a_position + a_offset;\n' +

            ' v_color = a_color;\n' +

            '}\n'

));

        decl.pushFragmentSource(new sglrShaderProgram.FragmentSource(

            '#version 300 es\n' +

            'layout(location = 0) out mediump vec4 dEQP_FragColor;\n' +

            'in mediump vec4 v_color;\n' +

            'void main(void)\n' +

            '{\n' +

            ' dEQP_FragColor = v_color;\n' +

            '}\n'

));

        sglrShaderProgram.ShaderProgram.call(this, decl);

};

    es3fDrawTests.GridProgram.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype);

    es3fDrawTests.GridProgram.prototype.constructor = es3fDrawTests.GridProgram;

/**

     * @param {Array<rrVertexAttrib.VertexAttrib>} inputs

     * @param {Array<rrVertexPacket.VertexPacket>} packets

     * @param {number} numPackets

*/

    es3fDrawTests.GridProgram.prototype.shadeVertices = function(inputs, packets, numPackets) {

        for (var ndx = 0; ndx < numPackets; ++ndx) {

            packets[ndx].position = deMath.add(

                rrVertexAttrib.readVertexAttrib(inputs[0], packets[ndx].instanceNdx, packets[ndx].vertexNdx, rrGenericVector.GenericVecType.FLOAT),

                rrVertexAttrib.readVertexAttrib(inputs[1], packets[ndx].instanceNdx, packets[ndx].vertexNdx, rrGenericVector.GenericVecType.FLOAT)

);

            packets[ndx].outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[2], packets[ndx].instanceNdx, packets[ndx].vertexNdx, rrGenericVector.GenericVecType.FLOAT);

};

/**

     * @param {Array<rrFragmentOperations.Fragment>} packets

     * @param {rrShadingContext.FragmentShadingContext} context

*/

    es3fDrawTests.GridProgram.prototype.shadeFragments = function(packets, context) {

        for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx)

        for (var fragNdx = 0; fragNdx < 4; ++fragNdx)

            packets[packetNdx].value = rrShadingContext.readTriangleVarying(packets[packetNdx], context, fragNdx);

};

/**

     * InstancedGridRenderTest

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

     * @param {string} name

     * @param {string} desc

     * @param {number} gridSide

     * @param {boolean} useIndices

*/

    es3fDrawTests.InstancedGridRenderTest = function(name, desc, gridSide, useIndices) {

        tcuTestCase.DeqpTest.call(this, name, desc);

        this.m_gridSide = gridSide;

        this.m_useIndices = useIndices;

};

    es3fDrawTests.InstancedGridRenderTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.InstancedGridRenderTest.prototype.constructor = es3fDrawTests.InstancedGridRenderTest;

/**

     * iterate

     * @return {tcuTestCase.IterateResult}

*/

    es3fDrawTests.InstancedGridRenderTest.prototype.iterate = function() {

        var renderTargetWidth = Math.min(1024, gl.canvas.width);

        var renderTargetHeight = Math.min(1024, gl.canvas.height);

        /** @type {sglrGLContext.GLContext} */ var ctx = new sglrGLContext.GLContext(gl);

        /** @type {tcuSurface.Surface} */ var surface = new tcuSurface.Surface(renderTargetWidth, renderTargetHeight);

        /** @type {es3fDrawTests.GridProgram} */ var program = new es3fDrawTests.GridProgram();

        // render

        this.renderTo(ctx, program, surface);

        // verify image

        if (this.verifyImage(surface))

            testPassed('');

        else

            testFailed('Incorrect rendering result');

        return tcuTestCase.IterateResult.STOP;

};

/**

     * @param {sglrGLContext.GLContext} ctx

     * @param {sglrShaderProgram.ShaderProgram} program

     * @param {tcuSurface.Surface} dst

*/

    es3fDrawTests.InstancedGridRenderTest.prototype.renderTo = function(ctx, program, dst) {

        var green = [0, 1, 0, 1];

        var yellow = [1, 1, 0, 1];

        /** @type {WebGLBuffer} */ var positionBuf = null;

        /** @type {WebGLBuffer} */ var offsetBuf = null;

        /** @type {WebGLBuffer} */ var colorBuf = null;

        /** @type {WebGLBuffer} */ var indexBuf = null;

        /** @type {WebGLProgram} */ var programID = ctx.createProgram(program);

        /** @type {number} */ var posLocation = ctx.getAttribLocation(/** @type {WebGLProgram} */ (programID), 'a_position');

        /** @type {number} */ var offsetLocation = ctx.getAttribLocation(/** @type {WebGLProgram} */ (programID), 'a_offset');

        /** @type {number} */ var colorLocation = ctx.getAttribLocation(/** @type {WebGLProgram} */ (programID), 'a_color');

        var cellW = 2.0 / this.m_gridSide;

        var cellH = 2.0 / this.m_gridSide;

        var vertexPositions = new Float32Array([

            0, 0, 0, 1,

            cellW, 0, 0, 1,

            0, cellH, 0, 1,

            0, cellH, 0, 1,

            cellW, 0, 0, 1,

            cellW, cellH, 0, 1

]);

        var indices = new Uint16Array([

            0, 4, 3,

            2, 1, 5

]);

        var offsets = [];

        for (var x = 0; x < this.m_gridSide; ++x)

        for (var y = 0; y < this.m_gridSide; ++y) {

            offsets.push(x * cellW - 1.0);

            offsets.push(y * cellW - 1.0);

            offsets.push(0, 0);

        offsets = new Float32Array(offsets);

        var colors = [];

        for (var x = 0; x < this.m_gridSide; ++x)

        for (var y = 0; y < this.m_gridSide; ++y) {

            var colorToPush = ((x + y) % 2 == 0) ? (green) : (yellow);

            colors.push(colorToPush[0]);

            colors.push(colorToPush[1]);

            colors.push(colorToPush[2]);

            colors.push(colorToPush[3]);

        colors = new Float32Array(colors);

        positionBuf = ctx.createBuffer();

        ctx.bindBuffer(gl.ARRAY_BUFFER, positionBuf);

        ctx.bufferData(gl.ARRAY_BUFFER, vertexPositions, gl.STATIC_DRAW);

        ctx.vertexAttribPointer(posLocation, 4, gl.FLOAT, false, 0, 0);

        ctx.vertexAttribDivisor(posLocation, 0);

        ctx.enableVertexAttribArray(posLocation);

        offsetBuf = ctx.createBuffer();

        ctx.bindBuffer(gl.ARRAY_BUFFER, offsetBuf);

        ctx.bufferData(gl.ARRAY_BUFFER, offsets, gl.STATIC_DRAW);

        ctx.vertexAttribPointer(offsetLocation, 4, gl.FLOAT, false, 0, 0);

        ctx.vertexAttribDivisor(offsetLocation, 1);

        ctx.enableVertexAttribArray(offsetLocation);

        colorBuf = ctx.createBuffer();

        ctx.bindBuffer(gl.ARRAY_BUFFER, colorBuf);

        ctx.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);

        ctx.vertexAttribPointer(colorLocation, 4, gl.FLOAT, false, 0, 0);

        ctx.vertexAttribDivisor(colorLocation, 1);

        ctx.enableVertexAttribArray(colorLocation);

        if (this.m_useIndices) {

            indexBuf = ctx.createBuffer();

            ctx.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuf);

            ctx.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);

        ctx.clearColor(0, 0, 0, 1);

        ctx.clear(gl.COLOR_BUFFER_BIT);

        ctx.viewport(0, 0, dst.getWidth(), dst.getHeight());

        ctx.useProgram(programID);

        if (this.m_useIndices)

            ctx.drawElementsInstanced(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0, this.m_gridSide * this.m_gridSide);

        else

            ctx.drawArraysInstanced(gl.TRIANGLES, 0, 6, this.m_gridSide * this.m_gridSide);

        ctx.useProgram(null);

        if (this.m_useIndices)

            ctx.deleteBuffer(indexBuf);

        ctx.deleteBuffer(colorBuf);

        ctx.deleteBuffer(offsetBuf);

        ctx.deleteBuffer(positionBuf);

        ctx.deleteProgram(programID);

        ctx.finish();

        dst.readViewport(ctx, [0 , 0, dst.getWidth(), dst.getHeight()]);

};

/**

     * @param {tcuSurface.Surface} image

     * @return {boolean}

*/

    es3fDrawTests.InstancedGridRenderTest.prototype.verifyImage = function(image) {

        // \note the green/yellow pattern is only for clarity. The test will only verify that all instances were drawn by looking for anything non-green/yellow.

        var green = [0, 255, 0, 255];

        var yellow = [255, 255, 0, 255];

        var colorThreshold = 20;

        /** @type {tcuSurface.Surface} */ var error = new tcuSurface.Surface(image.getWidth(), image.getHeight());

        var isOk = true;

        for (var y = 1; y < image.getHeight() - 1; y++)

        for (var x = 1; x < image.getWidth() - 1; x++) {

            /** @type {tcuRGBA.RGBA} */ var pixel = new tcuRGBA.RGBA(image.getPixel(x, y));

            var pixelOk = true;

            // Any pixel with !(G ~= 255) is faulty (not a linear combinations of green and yellow)

            if (Math.abs(pixel.getGreen() - 255) > colorThreshold)

                pixelOk = false;

            // Any pixel with !(B ~= 0) is faulty (not a linear combinations of green and yellow)

            if (Math.abs(pixel.getBlue() - 0) > colorThreshold)

                pixelOk = false;

            error.setPixel(x, y, pixelOk ? [0, 255, 0, 255] : [255, 0, 0, 255]);

            isOk = isOk && pixelOk;

        if (!isOk) {

            bufferedLogToConsole('Image verification failed.');

            debug('Verfication result');

            tcuLogImage.logImageWithInfo(image.getAccess(), 'Result');

            tcuLogImage.logImageWithInfo(error.getAccess(), 'Error mask');

        } else {

            debug('Verfication result');

        return isOk;

};

/**

     * InstancingGroup

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

*/

    es3fDrawTests.InstancingGroup = function(name, descr) {

        tcuTestCase.DeqpTest.call(this, name, descr);

        this.makeExecutable();

};

    es3fDrawTests.InstancingGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.InstancingGroup.prototype.constructor = es3fDrawTests.InstancingGroup;

/**

     * init

*/

    es3fDrawTests.InstancingGroup.prototype.init = function() {

        var gridWidths = [

2,

5,

10,

32,

];

        // drawArrays

        for (var ndx = 0; ndx < gridWidths.length; ++ndx) {

            var name = 'draw_arrays_instanced_grid_' + gridWidths[ndx] + 'x' + gridWidths[ndx];

            var desc = 'DrawArraysInstanced, Grid size ' + gridWidths[ndx] + 'x' + gridWidths[ndx];

            this.addChild(new es3fDrawTests.InstancedGridRenderTest(name, desc, gridWidths[ndx], false));

        // drawElements

        for (var ndx = 0; ndx < gridWidths.length; ++ndx) {

            var name = 'draw_elements_instanced_grid_' + gridWidths[ndx] + 'x' + gridWidths[ndx];

            var desc = 'DrawElementsInstanced, Grid size ' + gridWidths[ndx] + 'x' + gridWidths[ndx];

            this.addChild(new es3fDrawTests.InstancedGridRenderTest(name, desc, gridWidths[ndx], true));

};

/**

     * @constructor

     * @param {number} size

*/

    es3fDrawTests.UniformWeightArray = function(size) {

        this.weights = [];

        for (var i = 0; i < size; ++i)

            this.weights[i] = 1.0;

};

/**

     * RandomGroup

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

     * @param {string} name

     * @param {string} descr

*/

    es3fDrawTests.RandomGroup = function(name, descr) {

        tcuTestCase.DeqpTest.call(this, name, descr);

        this.makeExecutable();

};

    es3fDrawTests.RandomGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.RandomGroup.prototype.constructor = es3fDrawTests.RandomGroup;

/**

     * init

*/

    es3fDrawTests.RandomGroup.prototype.init = function() {

        /** @type {number} */ var numAttempts = 300;

        /** @type {Array<number>} */ var attribCounts = [1, 2, 5];

        /** @type {Array<number>} */ var attribWeights = [30, 10, 1];

        /** @type {Array<number>} */ var primitiveCounts = [2, 6, 64];

        /** @type {Array<number>} */ var primitiveCountWeights = [20, 10, 1];

        /** @type {Array<number>} */ var indexOffsets = [0, 7, 13];

        /** @type {Array<number>} */ var indexOffsetWeights = [20, 20, 1];

        /** @type {Array<number>} */ var firsts = [0, 6, 12];

        /** @type {Array<number>} */ var firstWeights = [20, 20, 1];

        /** @type {Array<number>} */ var instanceCounts = [1, 2, 16, 17];

        /** @type {Array<number>} */ var instanceWeights = [20, 10, 5, 1];

        /** @type {Array<number>} */ var indexMins = [0, 1, 3, 9];

        /** @type {Array<number>} */ var indexMaxs = [5, 9, 129, 257];

        /** @type {Array<number>} */ var indexWeights = [50, 50, 50, 50];

        /** @type {Array<number>} */ var offsets = [0, 1, 5, 12];

        /** @type {Array<number>} */ var offsetWeights = [50, 10, 10, 10];

        /** @type {Array<number>} */ var strides = [0, 7, 16, 17];

        /** @type {Array<number>} */ var strideWeights = [50, 10, 10, 10];

        /** @type {Array<number>} */ var instanceDivisors = [0, 1, 3, 129];

        /** @type {Array<number>} */ var instanceDivisorWeights = [70, 30, 10, 10];

        /** @type {Array<glsDrawTests.DrawTestSpec.Primitive>} */ var primitives = [

            glsDrawTests.DrawTestSpec.Primitive.POINTS,

            glsDrawTests.DrawTestSpec.Primitive.TRIANGLES,

            glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN,

            glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP,

            glsDrawTests.DrawTestSpec.Primitive.LINES,

            glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP,

            glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var primitiveWeights = new es3fDrawTests.UniformWeightArray(primitives.length);

        /** @type {Array<glsDrawTests.DrawTestSpec.DrawMethod>} */ var drawMethods = [

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var drawMethodWeights = new es3fDrawTests.UniformWeightArray(drawMethods.length);

        /** @type {Array<glsDrawTests.DrawTestSpec.IndexType>} */ var indexTypes = [

            glsDrawTests.DrawTestSpec.IndexType.BYTE,

            glsDrawTests.DrawTestSpec.IndexType.SHORT,

            glsDrawTests.DrawTestSpec.IndexType.INT

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var indexTypeWeights = new es3fDrawTests.UniformWeightArray(indexTypes.length);

        /** @type {Array<glsDrawTests.DrawTestSpec.Storage>} */ var storages = [

            //glsDrawTests.DrawTestSpec.Storage.USER,

            glsDrawTests.DrawTestSpec.Storage.BUFFER

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var storageWeights = new es3fDrawTests.UniformWeightArray(storages.length);

        /** @type {Array<glsDrawTests.DrawTestSpec.InputType>} */ var inputTypes = [

            glsDrawTests.DrawTestSpec.InputType.FLOAT,

            //glsDrawTests.DrawTestSpec.InputType.FIXED,

            glsDrawTests.DrawTestSpec.InputType.BYTE,

            glsDrawTests.DrawTestSpec.InputType.SHORT,

            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE,

            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT,

            glsDrawTests.DrawTestSpec.InputType.INT,

            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT,

            glsDrawTests.DrawTestSpec.InputType.HALF,

            glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10,

            glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var inputTypeWeights = new es3fDrawTests.UniformWeightArray(inputTypes.length);

        /** @type {Array<glsDrawTests.DrawTestSpec.OutputType>} */ var outputTypes = [

            glsDrawTests.DrawTestSpec.OutputType.FLOAT,

            glsDrawTests.DrawTestSpec.OutputType.VEC2,

            glsDrawTests.DrawTestSpec.OutputType.VEC3,

            glsDrawTests.DrawTestSpec.OutputType.VEC4,

            glsDrawTests.DrawTestSpec.OutputType.INT,

            glsDrawTests.DrawTestSpec.OutputType.UINT,

            glsDrawTests.DrawTestSpec.OutputType.IVEC2,

            glsDrawTests.DrawTestSpec.OutputType.IVEC3,

            glsDrawTests.DrawTestSpec.OutputType.IVEC4,

            glsDrawTests.DrawTestSpec.OutputType.UVEC2,

            glsDrawTests.DrawTestSpec.OutputType.UVEC3,

            glsDrawTests.DrawTestSpec.OutputType.UVEC4

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var outputTypeWeights = new es3fDrawTests.UniformWeightArray(outputTypes.length);

        /** @type {Array<glsDrawTests.DrawTestSpec.Usage>} */ var usages = [

            glsDrawTests.DrawTestSpec.Usage.DYNAMIC_DRAW,

            glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW,

            glsDrawTests.DrawTestSpec.Usage.STREAM_DRAW,

            glsDrawTests.DrawTestSpec.Usage.STREAM_READ,

            glsDrawTests.DrawTestSpec.Usage.STREAM_COPY,

            glsDrawTests.DrawTestSpec.Usage.STATIC_READ,

            glsDrawTests.DrawTestSpec.Usage.STATIC_COPY,

            glsDrawTests.DrawTestSpec.Usage.DYNAMIC_READ,

            glsDrawTests.DrawTestSpec.Usage.DYNAMIC_COPY

];

        /** @type {es3fDrawTests.UniformWeightArray} */ var usageWeights = new es3fDrawTests.UniformWeightArray(usages.length);

        /** @type {Array<number>} */ var insertedHashes = []; //'set' structure

        /** @type {number} */ var insertedCount = 0;

        for (var ndx = 0; ndx < numAttempts; ++ndx) {

            /** @type {deRandom.Random} */ var random = new deRandom.Random(0xc551393 + ndx); // random does not depend on previous cases

            /** @type {number} */ var attributeCount = random.chooseWeighted(attribCounts, attribWeights);

            /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec();

            //spec.apiType = glu::ApiType::es(3,0);

            spec.primitive = /** @type {glsDrawTests.DrawTestSpec.Primitive} */ (random.chooseWeighted(primitives, primitiveWeights.weights));

            spec.primitiveCount = random.chooseWeighted(primitiveCounts, primitiveCountWeights);

            spec.drawMethod = /** @type {glsDrawTests.DrawTestSpec.DrawMethod} */ (random.chooseWeighted(drawMethods, drawMethodWeights.weights));

            spec.indexType = /** @type {glsDrawTests.DrawTestSpec.IndexType} */ (random.chooseWeighted(indexTypes, indexTypeWeights.weights));

            spec.indexPointerOffset = random.chooseWeighted(indexOffsets, indexOffsetWeights);

            spec.indexStorage = /** @type {glsDrawTests.DrawTestSpec.Storage} */ (random.chooseWeighted(storages, storageWeights.weights));

            spec.first = random.chooseWeighted(firsts, firstWeights);

            spec.indexMin = random.chooseWeighted(indexMins, indexWeights);

            spec.indexMax = random.chooseWeighted(indexMaxs, indexWeights);

            spec.instanceCount = random.chooseWeighted(instanceCounts, instanceWeights);

            // check spec is legal

            if (!spec.valid())

                continue;

            var hasZeroDivisor = false;

            for (var attrNdx = 0; attrNdx < attributeCount;) {

                /** @type {boolean} */ var valid;

                /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = new glsDrawTests.DrawTestSpec.AttributeSpec();

                attribSpec.inputType = /** @type {glsDrawTests.DrawTestSpec.InputType} */ (random.chooseWeighted(inputTypes, inputTypeWeights.weights));

                attribSpec.outputType = /** @type {glsDrawTests.DrawTestSpec.OutputType} */ (random.chooseWeighted(outputTypes, outputTypeWeights.weights));

                attribSpec.storage = /** @type {glsDrawTests.DrawTestSpec.Storage} */ (random.chooseWeighted(storages, storageWeights.weights));

                attribSpec.usage = /** @type {glsDrawTests.DrawTestSpec.Usage} */ (random.chooseWeighted(usages, usageWeights.weights));

                attribSpec.componentCount = random.getInt(1, 4);

                attribSpec.offset = random.chooseWeighted(offsets, offsetWeights);

                attribSpec.stride = random.chooseWeighted(strides, strideWeights);

                attribSpec.normalize = random.getBool();

                attribSpec.instanceDivisor = random.chooseWeighted(instanceDivisors, instanceDivisorWeights);

                attribSpec.useDefaultAttribute = random.getBool();

                // check spec is legal

                valid = attribSpec.valid(/*spec.apiType*/);

                // we do not want interleaved elements. (Might result in some weird floating point values)

                if (attribSpec.stride && attribSpec.componentCount * glsDrawTests.DrawTestSpec.inputTypeSize(attribSpec.inputType) > attribSpec.stride)

                    valid = false;

                // try again if not valid

                if (valid) {

                    spec.attribs.push(attribSpec);

                    ++attrNdx;

                    if (attribSpec.instanceDivisor == 0)

                        hasZeroDivisor = true;

            // Do not collapse all vertex positions to a single positions

            if (spec.primitive != glsDrawTests.DrawTestSpec.Primitive.POINTS) {

                spec.attribs[0].instanceDivisor = 0;

                hasZeroDivisor = true;

            // There should be at least one enabled vertex attribute array that has a divisor of zero in WebGL.

            // This limitation is added to keep compatible with D3D. It differs from the feature in gles.

            // See the section <Enabled Attribute> in WebGL spec: https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.6

            if (hasZeroDivisor == false)

                continue;

            // Is render result meaningful?

            // Only one vertex

            if (spec.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED && spec.indexMin == spec.indexMax && spec.primitive != glsDrawTests.DrawTestSpec.Primitive.POINTS)

                continue;

            if (spec.attribs[0].useDefaultAttribute && spec.primitive != glsDrawTests.DrawTestSpec.Primitive.POINTS)

                continue;

            // Triangle only on one axis

            if (spec.primitive == glsDrawTests.DrawTestSpec.Primitive.TRIANGLES || spec.primitive == glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN || spec.primitive == glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP) {

                if (spec.attribs[0].componentCount == 1)

                    continue;

                if (spec.attribs[0].outputType == glsDrawTests.DrawTestSpec.OutputType.FLOAT || spec.attribs[0].outputType == glsDrawTests.DrawTestSpec.OutputType.INT || spec.attribs[0].outputType == glsDrawTests.DrawTestSpec.OutputType.UINT)

                    continue;

                if (spec.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED && (spec.indexMax - spec.indexMin) < 2)

                    continue;

            // Add case

            /** @type {number} */ var hash = spec.hash();

            for (var attrNdx = 0; attrNdx < attributeCount; ++attrNdx)

                hash = deMath.binaryOp(deMath.shiftLeft(hash, 2), spec.attribs[attrNdx].hash(), deMath.BinaryOp.XOR);

            if (insertedHashes.indexOf(hash) == -1) {

                // Only properly aligned

                if (spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET &&

                    spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE) {

                    this.addChild(new glsDrawTests.DrawTest(spec, insertedCount + '', spec.getDesc()));

                deUtil.dePushUniqueToArray(insertedHashes, hash);

                ++insertedCount;

};

/**

     * @constructor

     * @extends {tcuTestCase.DeqpTest}

*/

    es3fDrawTests.DrawTest = function() {

        tcuTestCase.DeqpTest.call(this, 'draw', 'Drawing tests');

        this.makeExecutable();

};

    es3fDrawTests.DrawTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype);

    es3fDrawTests.DrawTest.prototype.constructor = es3fDrawTests.DrawTest;

/**

     * init

*/

    es3fDrawTests.DrawTest.prototype.init = function() {

        // Basic

        /** @type {Array<glsDrawTests.DrawTestSpec.DrawMethod>} */ var basicMethods = [

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED,

            glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED

];

        for (var ndx = 0; ndx < basicMethods.length; ++ndx) {

            var name = glsDrawTests.DrawTestSpec.drawMethodToString(basicMethods[ndx]);

            var desc = glsDrawTests.DrawTestSpec.drawMethodToString(basicMethods[ndx]);

            this.addChild(new es3fDrawTests.MethodGroup(name, desc, basicMethods[ndx]));

        // extreme instancing

        this.addChild(new es3fDrawTests.InstancingGroup('instancing', 'draw tests with a large instance count.'));

        // Random

        this.addChild(new es3fDrawTests.RandomGroup('random', 'random draw commands.'));

};

/**

     * Create and execute the test cases

     * @param {WebGL2RenderingContext} context

*/

    es3fDrawTests.run = function(context, range) {

        gl = context;

        //Set up Test Root parameters

        var state = tcuTestCase.runner;

        var rootTest = new es3fDrawTests.DrawTest();

        state.setRoot(rootTest);

        //Set up name and description of this test series.

        setCurrentTestName(rootTest.fullName());

        description(rootTest.getDescription());

        try {

            if (range) {

                state.setRange(range);

            //Run test cases

            tcuTestCase.runTestCases();

        catch (err) {

            testFailedOptions('Failed to run draw tests', false);

            tcuTestCase.runner.terminate();

};

});