Source code
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
*
*
* 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();
}
};
});