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

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the 'License');
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an 'AS IS' BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

'use strict';
goog.provide('functional.gles3.es3fDefaultVertexAttributeTests');
goog.require('framework.common.tcuLogImage');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');

goog.scope(function() {
var es3fDefaultVertexAttributeTests = functional.gles3.es3fDefaultVertexAttributeTests;
var tcuTestCase = framework.common.tcuTestCase;
var tcuSurface = framework.common.tcuSurface;
var deMath = framework.delibs.debase.deMath;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var tcuLogImage = framework.common.tcuLogImage;

var setParentClass = function(child, parent) {
    child.prototype = Object.create(parent.prototype);
    child.prototype.constructor = child;
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib1f = function() {
    this.caseName = 'vertex_attrib_1f';
    this.name = 'VertexAttrib1f';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib1f(index, value[0]);
        return [value[0], 0, 0, 1];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib2f = function() {
    this.caseName = 'vertex_attrib_2f';
    this.name = 'VertexAttrib2f';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib2f(index, value[0], value[1]);
        return [value[0], value[1], 0, 1];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib3f = function() {
    this.caseName = 'vertex_attrib_3f';
    this.name = 'VertexAttrib3f';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib3f(index, value[0], value[1], value[2]);
        return [value[0], value[1], value[2], 1];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib4f = function() {
    this.caseName = 'vertex_attrib_4f';
    this.name = 'VertexAttrib4f';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib4f(index, value[0], value[1], value[2], value[3]);
        return [value[0], value[1], value[2], value[3]];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib1fv = function() {
    this.caseName = 'vertex_attrib_1fv';
    this.name = 'VertexAttrib1fv';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib1fv(index, value.slice(0, 1));
        return [value[0], 0, 0, 1];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib2fv = function() {
    this.caseName = 'vertex_attrib_2fv';
    this.name = 'VertexAttrib2fv';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib2fv(index, value.slice(0, 2));
        return [value[0], value[1], 0, 1];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib3fv = function() {
    this.caseName = 'vertex_attrib_3fv';
    this.name = 'VertexAttrib3fv';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib3fv(index, value.slice(0, 3));
        return [value[0], value[1], value[2], 1];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttrib4fv = function() {
    this.caseName = 'vertex_attrib_4fv';
    this.name = 'VertexAttrib4fv';
    this.signed = true;
    this.load = function(index, value) {
        gl.vertexAttrib4fv(index, value.slice(0, 4));
        return [value[0], value[1], value[2], value[3]];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttribI4i = function() {
    this.caseName = 'vertex_attrib_4i';
    this.name = 'VertexAttribI4i';
    this.signed = true;
    this.load = function(index, value) {
        var v = new Int32Array(value);
        gl.vertexAttribI4i(index, v[0], v[1], v[2], v[3]);
        return [v[0], v[1], v[2], v[3]];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttribI4iv = function() {
    this.caseName = 'vertex_attrib_4iv';
    this.name = 'VertexAttribI4iv';
    this.signed = true;
    this.load = function(index, value) {
        var v = new Int32Array(value);
        gl.vertexAttribI4iv(index, v);
        return [v[0], v[1], v[2], v[3]];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttribI4ui = function() {
    this.caseName = 'vertex_attrib_4ui';
    this.name = 'VertexAttribI4ui';
    this.signed = false;
    this.load = function(index, value) {
        var v = new Uint32Array(value);
        gl.vertexAttribI4ui(index, v[0], v[1], v[2], v[3]);
        return [v[0], v[1], v[2], v[3]];
    };
};

/**
 * @constructor
 */
es3fDefaultVertexAttributeTests.LoaderVertexAttribI4uiv = function() {
    this.caseName = 'vertex_attrib_4uiv';
    this.name = 'VertexAttribI4uiv';
    this.signed = false;
    this.load = function(index, value) {
        var v = new Uint32Array(value);
        gl.vertexAttribI4uiv(index, v);
        return [v[0], v[1], v[2], v[3]];
    };
};

/** @const */ var RENDER_SIZE = 32;
/** @const */ var s_valueRange = 10;
/** @const */ var s_passThroughFragmentShaderSource = '#version 300 es\n' +
                                                        'layout(location = 0) out mediump vec4 fragColor;\n' +
                                                        'in mediump vec4 v_color;\n' +
                                                        'void main (void)\n' +
                                                        '{\n' +
                                                        ' fragColor = v_color;\n' +
                                                        '}\n';

/**
 * @constructor
 * @extends {tcuTestCase.DeqpTest}
 */
es3fDefaultVertexAttributeTests.AttributeCase = function(loaderType, dataType) {
    var loader = new loaderType();
    var name = loader.caseName;
    var description = 'Test ' + loader.name;
    tcuTestCase.DeqpTest.call(this, name, description);
    this.m_funcName = loader.name;
    this.m_useNegativeValues = loader.signed;
    this.m_dataType = dataType;
    this.m_allIterationsPassed = true;
    this.m_loader = loader;
    this.m_iteration = 0;
};

setParentClass(es3fDefaultVertexAttributeTests.AttributeCase, tcuTestCase.DeqpTest);

es3fDefaultVertexAttributeTests.AttributeCase.prototype.init = function() {
    // log test info

    var maxRange = s_valueRange;
    var minRange = (this.m_useNegativeValues) ? (-maxRange) : (0.0);

    bufferedLogToConsole(
        'Loading attribute values using ' + this.m_funcName + '\n' +
        'Attribute type: ' + gluShaderUtil.getDataTypeName(this.m_dataType) + '\n' +
        'Attribute value range: [' + minRange + ', ' + maxRange + ']');

    // gen shader and base quad

    this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(this.genVertexSource(), s_passThroughFragmentShaderSource));
    if (!this.m_program.isOk())
        testFailedOptions('could not build program', true);

    var fullscreenQuad = [
         1.0, 1.0, 0.0, 1.0,
         1.0, -1.0, 0.0, 1.0,
        -1.0, 1.0, 0.0, 1.0,
        -1.0, -1.0, 0.0, 1.0
    ];

    this.m_bufID = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, this.m_bufID);
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(fullscreenQuad), gl.STATIC_DRAW);
};

es3fDefaultVertexAttributeTests.AttributeCase.prototype.deinit = function() {
    this.m_loader = null;

    gl.useProgram(null);
    this.m_program = null;

    if (this.m_bufID) {
        gl.deleteBuffer(this.m_bufID);
        this.m_bufID = null;
    }
};

es3fDefaultVertexAttributeTests.AttributeCase.prototype.iterate = function() {
    var testValues = [
        [0.0, 0.5, 0.2, 1.0],
        [0.1, 0.7, 1.0, 0.6],
        [0.4, 0.2, 0.0, 0.5],
        [0.5, 0.0, 0.9, 0.1],
        [0.6, 0.2, 0.2, 0.9],
        [0.9, 1.0, 0.0, 0.0],
        [1.0, 0.5, 0.3, 0.8]
    ];

    bufferedLogToConsole('Iteration ' + (this.m_iteration + 1) + '/' + testValues.length);

    var testValue = this.m_useNegativeValues ?
        deMath.subScalar(deMath.scale(testValues[this.m_iteration], 2), 1) :
        deMath.scale(testValues[this.m_iteration], s_valueRange);

    if (!this.renderWithValue(testValue))
        this.m_allIterationsPassed = false;

    // continue

    if (++this.m_iteration < testValues.length)
        return tcuTestCase.IterateResult.CONTINUE;

    if (this.m_allIterationsPassed)
        testPassed();
    else
        testFailed('Got unexpected values');

    return tcuTestCase.IterateResult.STOP;
};

es3fDefaultVertexAttributeTests.AttributeCase.prototype.genVertexSource = function() {
    var vectorSize = (gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeMatrixNumRows(this.m_dataType)) : (gluShaderUtil.isDataTypeVector(this.m_dataType)) ? (gluShaderUtil.getDataTypeScalarSize(this.m_dataType)) : (-1);
    var vectorType = gluShaderUtil.getDataTypeName((gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeVector(gluShaderUtil.DataType.FLOAT, vectorSize)) : (gluShaderUtil.isDataTypeVector(this.m_dataType)) ? (gluShaderUtil.getDataTypeVector(gluShaderUtil.DataType.FLOAT, vectorSize)) : (gluShaderUtil.DataType.FLOAT));
    var components = (gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeMatrixNumRows(this.m_dataType)) : (gluShaderUtil.getDataTypeScalarSize(this.m_dataType));

    var buf = '#version 300 es\n' +
            'in highp vec4 a_position;\n' +
            'in highp ' + gluShaderUtil.getDataTypeName(this.m_dataType) + ' a_value;\n' +
            'out highp vec4 v_color;\n' +
            'void main (void)\n' +
            '{\n' +
            ' gl_Position = a_position;\n' +
            '\n';

    buf += ' highp ' + vectorType + ' normalizedValue = ' + ((gluShaderUtil.getDataTypeScalarType(this.m_dataType) == gluShaderUtil.DataType.FLOAT) ? ('') : (vectorType)) + '(a_value' + ((gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? ('[1]') : ('')) + ') / float(' + s_valueRange + ');\n';

    if (this.m_useNegativeValues)
        buf += ' highp ' + vectorType + ' positiveNormalizedValue = (normalizedValue + ' + vectorType + '(1.0)) / 2.0;\n';
    else
        buf += ' highp ' + vectorType + ' positiveNormalizedValue = normalizedValue;\n';

    if (components == 1)
        buf += ' v_color = vec4(positiveNormalizedValue, 0.0, 0.0, 1.0);\n';
    else if (components == 2)
        buf += ' v_color = vec4(positiveNormalizedValue.xy, 0.0, 1.0);\n';
    else if (components == 3)
        buf += ' v_color = vec4(positiveNormalizedValue.xyz, 1.0);\n';
    else if (components == 4)
        buf += ' v_color = vec4((positiveNormalizedValue.xy + positiveNormalizedValue.zz) / 2.0, positiveNormalizedValue.w, 1.0);\n';
    else
       throw new Error('Wrong component size: ' + components);

    buf += '}\n';

    return buf;
};

es3fDefaultVertexAttributeTests.AttributeCase.prototype.renderWithValue = function(v) {
    var positionIndex = gl.getAttribLocation(this.m_program.getProgram(), 'a_position');
    var valueIndex = gl.getAttribLocation(this.m_program.getProgram(), 'a_value');
    var dest = new tcuSurface.Surface(RENDER_SIZE, RENDER_SIZE);

    gl.clearColor(0.0, 0.0, 0.0, 0.0);
    gl.clear(gl.COLOR_BUFFER_BIT);
    gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);

    gl.bindBuffer(gl.ARRAY_BUFFER, this.m_bufID);
    gl.vertexAttribPointer(positionIndex, 4, gl.FLOAT, false, 0, 0);
    gl.enableVertexAttribArray(positionIndex);

    // transfer test value. Load to the second column in the matrix case
    var loadedValue = this.m_loader.load((gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (valueIndex + 1) : (valueIndex), v);

    gl.useProgram(this.m_program.getProgram());
    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
    gl.useProgram(null);
    // The original c++ test does not disable vertex attrib array, which is wrong.
    // On most drivers all tests pass because a_position is assigned location 0.
    // On MacOSX some tests fail because a_value is assigned location 0 and vertex
    // attrib array is left enabled and affects later tests.
    gl.disableVertexAttribArray(positionIndex);
    dest.readViewport(gl);

    // check whole result is colored correctly
    return this.verifyUnicoloredBuffer(dest, this.computeColor(loadedValue));
};

es3fDefaultVertexAttributeTests.AttributeCase.prototype.computeColor = function(value) {
    var normalizedValue = deMath.scale(value, 1 / s_valueRange);
    var positiveNormalizedValue = this.m_useNegativeValues ?
        deMath.scale(deMath.addScalar(normalizedValue, 1), 0.5) :
        normalizedValue;
    var components = (gluShaderUtil.isDataTypeMatrix(this.m_dataType)) ? (gluShaderUtil.getDataTypeMatrixNumRows(this.m_dataType)) : (gluShaderUtil.getDataTypeScalarSize(this.m_dataType));

    if (components == 1)
        return [positiveNormalizedValue[0], 0.0, 0.0, 1.0];
    else if (components == 2)
        return [positiveNormalizedValue[0], positiveNormalizedValue[1], 0.0, 1.0];
    else if (components == 3)
        return [positiveNormalizedValue[0], positiveNormalizedValue[1], positiveNormalizedValue[2], 1.0];
    else if (components == 4)
        return [(positiveNormalizedValue[0] + positiveNormalizedValue[2]) / 2.0, (positiveNormalizedValue[1] + positiveNormalizedValue[2]) / 2.0, positiveNormalizedValue[3], 1.0];
    else
       throw new Error('Wrong component size: ' + components);
};

/**
 * @param {tcuSurface.Surface} scene
 * @param {Array<number>} refColor
 * @return {boolean}
 */
es3fDefaultVertexAttributeTests.AttributeCase.prototype.verifyUnicoloredBuffer = function(scene, refColor) {
    var access = scene.getAccess();
    var errorMask = new tcuSurface.Surface(RENDER_SIZE, RENDER_SIZE);
    var colorThreshold = [6, 6, 6, 6];
    var error = false;

    errorMask.getAccess().clear([0, 1, 0, 1]);

    bufferedLogToConsole('Verifying rendered image. Expecting color ' + refColor + ', threshold ' + colorThreshold);

    for (var y = 0; y < RENDER_SIZE; ++y)
    for (var x = 0; x < RENDER_SIZE; ++x) {
        var color = access.getPixel(x, y);

        if (Math.abs(color[0] - refColor[0]) > colorThreshold[0] ||
            Math.abs(color[1] - refColor[1]) > colorThreshold[1] ||
            Math.abs(color[2] - refColor[2]) > colorThreshold[2]) {

            // first error
            if (!error)
                debug('Found invalid pixel(s). Pixel at (' + x + ', ' + y + ') color: ' + color);

            error = true;
            errorMask.setPixel(x, y, [1, 0, 0, 1]);
        }
    }

    if (!error)
        bufferedLogToConsole('Rendered image is valid.');
    else {
        tcuLogImage.logImage('Result', '', access);
        tcuLogImage.logImage('Error mask', '', errorMask.getAccess());
    }

    return !error;
};

/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests = function() {
    tcuTestCase.DeqpTest.call(this, 'default_vertex_attrib', 'Test default vertex attributes');
};

es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests.prototype.constructor = es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests;

es3fDefaultVertexAttributeTests.DefaultVertexAttributeTests.prototype.init = function() {
    var tests = this;
    var floatTargets = [
        ['float', gluShaderUtil.DataType.FLOAT, false],
        ['vec2', gluShaderUtil.DataType.FLOAT_VEC2, true],
        ['vec3', gluShaderUtil.DataType.FLOAT_VEC3, true],
        ['vec4', gluShaderUtil.DataType.FLOAT_VEC4, false],
        ['mat2', gluShaderUtil.DataType.FLOAT_MAT2, true],
        ['mat2x3', gluShaderUtil.DataType.FLOAT_MAT2X3, true],
        ['mat2x4', gluShaderUtil.DataType.FLOAT_MAT2X4, true],
        ['mat3', gluShaderUtil.DataType.FLOAT_MAT3, true],
        ['mat3x2', gluShaderUtil.DataType.FLOAT_MAT3X2, true],
        ['mat3x4', gluShaderUtil.DataType.FLOAT_MAT3X4, true],
        ['mat4', gluShaderUtil.DataType.FLOAT_MAT4, false],
        ['mat4x2', gluShaderUtil.DataType.FLOAT_MAT4X2, true],
        ['mat4x3', gluShaderUtil.DataType.FLOAT_MAT4X3, true]
    ];

    floatTargets.forEach(function(elem) {
        var name = elem[0];
        var dataType = elem[1];
        var reduced = elem[2];
        var group = new tcuTestCase.DeqpTest(name, 'test with ' + name);
        tests.addChild(group);
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib1f, dataType));
        if (!reduced) {
            group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib2f, dataType));
            group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib3f, dataType));
        }
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib4f, dataType));

        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib1fv, dataType));
        if (!reduced) {
            group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib2fv, dataType));
            group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib3fv, dataType));
        }
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttrib4fv, dataType));

    });

    var intTargets = [
        ['int', gluShaderUtil.DataType.INT, false],
        ['ivec2', gluShaderUtil.DataType.INT_VEC2, true],
        ['ivec3', gluShaderUtil.DataType.INT_VEC3, true],
        ['ivec4', gluShaderUtil.DataType.INT_VEC4, false]
    ];

   intTargets.forEach(function(elem) {
        var name = elem[0];
        var dataType = elem[1];
        var reduced = elem[2];
        var group = new tcuTestCase.DeqpTest(name, 'test with ' + name);
        tests.addChild(group);
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4i, dataType));
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4iv, dataType));
    });

    var uintTargets = [
        ['uint', gluShaderUtil.DataType.UINT, false],
        ['uvec2', gluShaderUtil.DataType.UINT_VEC2, true],
        ['uvec3', gluShaderUtil.DataType.UINT_VEC3, true],
        ['uvec4', gluShaderUtil.DataType.UINT_VEC4, false]
    ];

   uintTargets.forEach(function(elem) {
        var name = elem[0];
        var dataType = elem[1];
        var reduced = elem[2];
        var group = new tcuTestCase.DeqpTest(name, 'test with ' + name);
        tests.addChild(group);
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4ui, dataType));
        group.addChild(new es3fDefaultVertexAttributeTests.AttributeCase(es3fDefaultVertexAttributeTests.LoaderVertexAttribI4uiv, dataType));
    });

};

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

    //Set up name and description of this test series.
    setCurrentTestName(state.testCases.fullName());
    description(state.testCases.getDescription());

    try {
        //Run test cases
        tcuTestCase.runTestCases();
    }
    catch (err) {
        testFailedOptions('Failed to es3fDefaultVertexAttributeTests.run tests', false);
        tcuTestCase.runner.terminate();
    }
};

});