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.es3fTransformFeedbackTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluVarType');
goog.require('framework.opengl.gluVarTypeUtil');
goog.scope(function() {
var es3fTransformFeedbackTests = functional.gles3.es3fTransformFeedbackTests;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluDrawUtil = framework.opengl.gluDrawUtil;
var gluVarType = framework.opengl.gluVarType;
var gluVarTypeUtil = framework.opengl.gluVarTypeUtil;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var deRandom = framework.delibs.debase.deRandom;
var deMath = framework.delibs.debase.deMath;
var deString = framework.delibs.debase.deString;
var tcuTestCase = framework.common.tcuTestCase;
var tcuSurface = framework.common.tcuSurface;
var tcuImageCompare = framework.common.tcuImageCompare;
/** @type {WebGL2RenderingContext} */ var gl;
var setParentClass = function(child, parent) {
child.prototype = Object.create(parent.prototype);
child.prototype.constructor = child;
};
/**
* @enum
*/
es3fTransformFeedbackTests.State = {
DRAW: 0,
VERIFY: 1,
FINISH: 2
};
/* Maximum time to wait for query result (in seconds) */
/** @const */ es3fTransformFeedbackTests.MAX_VERIFY_WAIT = 5;
/** @const @type {number} */ es3fTransformFeedbackTests.VIEWPORT_WIDTH = 128;
/** @const @type {number} */ es3fTransformFeedbackTests.VIEWPORT_HEIGHT = 128;
/** @const @type {number} */ es3fTransformFeedbackTests.BUFFER_GUARD_MULTIPLIER = 2;
/**
* Enums for es3fTransformFeedbackTests.interpolation
* @enum {number}
*/
es3fTransformFeedbackTests.interpolation = {
SMOOTH: 0,
FLAT: 1,
CENTROID: 2
};
/**
* Returns es3fTransformFeedbackTests.interpolation name: smooth, flat or centroid
* @param {number} interpol es3fTransformFeedbackTests.interpolation enum value
* @return {string}
*/
es3fTransformFeedbackTests.getInterpolationName = function(interpol) {
switch (interpol) {
case es3fTransformFeedbackTests.interpolation.SMOOTH: return 'smooth';
case es3fTransformFeedbackTests.interpolation.FLAT: return 'flat';
case es3fTransformFeedbackTests.interpolation.CENTROID: return 'centroid';
default:
throw new Error('Unrecognized es3fTransformFeedbackTests.interpolation name ' + interpol);
}
};
/**
* @struct
* @param {string} name
* @param {gluVarType.VarType} type
* @param {number} interpolation
* @constructor
*/
es3fTransformFeedbackTests.Varying = function(name, type, interpolation) {
this.name = name;
this.type = type;
this.interpolation = interpolation;
};
/** es3fTransformFeedbackTests.findAttributeNameEquals
* Replaces original implementation of "VaryingNameEquals" and "AttributeNameEquals" in the C++ version
* Returns an es3fTransformFeedbackTests.Attribute or es3fTransformFeedbackTests.Varying object which matches its name with the passed string value in the function
* @param {(Array<es3fTransformFeedbackTests.Attribute> | Array<es3fTransformFeedbackTests.Varying>)} array
* @param {string} name
* @return { (es3fTransformFeedbackTests.Attribute | es3fTransformFeedbackTests.Varying | null)}
*/
es3fTransformFeedbackTests.findAttributeNameEquals = function(array, name) {
for (var pos = 0; pos < array.length; pos++) {
if (array[pos].name === name) {
return array[pos];
}
}
return null;
};
/**
* @struct
* @param {string} name
* @param {gluVarType.VarType} type
* @param {number} offset
* @constructor
*/
es3fTransformFeedbackTests.Attribute = function(name, type, offset) {
this.name = name;
this.type = type;
this.offset = offset;
};
/**
* Constructs an es3fTransformFeedbackTests.Output object
* @constructor
*/
es3fTransformFeedbackTests.Output = function() {
/** @type {number} */ this.bufferNdx = 0;
/** @type {number} */ this.offset = 0;
/** @type {string} */ this.name;
/** @type {gluVarType.VarType} */ this.type = null;
/** @type {Array<es3fTransformFeedbackTests.Attribute>} */ this.inputs = [];
};
/**
* Constructs an object type es3fTransformFeedbackTests.DrawCall.
* Contains the number of elements as well as whether the Transform Feedback is enabled or not.
* @struct
* @param {number} numElements
* @param {boolean} tfEnabled is Transform Feedback enabled or not
* @constructor
*/
es3fTransformFeedbackTests.DrawCall = function(numElements, tfEnabled) {
this.numElements = numElements;
this.transformFeedbackEnabled = tfEnabled;
};
/**
* @constructor
*/
es3fTransformFeedbackTests.ProgramSpec = function() {
/** @type {Array<gluVarType.StructType>} */ var m_structs = [];
/** @type {Array<es3fTransformFeedbackTests.Varying>} */ var m_varyings = [];
/** @type {Array<string>} */ var m_transformFeedbackVaryings = [];
this.createStruct = function(name) {
var struct = gluVarType.newStructType(name);
m_structs.push(struct);
return struct;
};
this.addVarying = function(name, type, interp) {
m_varyings.push(new es3fTransformFeedbackTests.Varying(name, type, interp));
};
this.addTransformFeedbackVarying = function(name) {
m_transformFeedbackVaryings.push(name);
};
this.getStructs = function() {
return m_structs;
};
this.getVaryings = function() {
return m_varyings;
};
this.getTransformFeedbackVaryings = function() {
return m_transformFeedbackVaryings;
};
this.isPointSizeUsed = function() {
for (var i = 0; i < m_transformFeedbackVaryings.length; ++i) {
if (m_transformFeedbackVaryings[i] == 'gl_PointSize') return true;
}
return false;
};
};
/** Returns if the program is supported or not
* @param {es3fTransformFeedbackTests.ProgramSpec} spec
* @param {number} tfMode
* @return {boolean}
*/
es3fTransformFeedbackTests.isProgramSupported = function(spec, tfMode) {
var maxVertexAttribs = Number(gl.getParameter(gl.MAX_VERTEX_ATTRIBS));
var maxTfInterleavedComponents = Number(gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS));
var maxTfSeparateAttribs = Number(gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS));
var maxTfSeparateComponents = Number(gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS));
// Check vertex attribs.
/** @type {number} */ var totalVertexAttribs = (
1 /* a_position */ + (spec.isPointSizeUsed() ? 1 : 0)
);
for (var i = 0; i < spec.getVaryings().length; ++i) {
for (var v_iter = new gluVarTypeUtil.VectorTypeIterator(spec.getVaryings()[i].type); !v_iter.end(); v_iter.next()) {
totalVertexAttribs += 1;
}
}
if (totalVertexAttribs > maxVertexAttribs)
return false; // Vertex attribute es3fTransformFeedbackTests.count exceeded.
// check varyings
/** @type {number} */ var totalTfComponents = 0;
/** @type {number} */ var totalTfAttribs = 0;
/** @type {Object.<number, number>} */ var presetNumComponents = {
gl_Position: 4,
gl_PointSize: 1
};
for (var i = 0; i < spec.getTransformFeedbackVaryings().length; ++i) {
var name = spec.getTransformFeedbackVaryings()[i];
var numComponents = 0;
if (typeof(presetNumComponents[name]) != 'undefined') {
numComponents = presetNumComponents[name];
} else {
var varName = gluVarTypeUtil.parseVariableName(name);
// find the varying called varName
/** @type {es3fTransformFeedbackTests.Varying} */ var varying = (function(varyings) {
for (var i = 0; i < varyings.length; ++i) {
if (varyings[i].name == varName) {
return varyings[i];
}
}
return null;
}(spec.getVaryings()));
// glu::TypeComponentVector
var varPath = gluVarTypeUtil.parseTypePath(name, varying.type);
numComponents = gluVarTypeUtil.getVarType(varying.type, varPath).getScalarSize();
}
if (tfMode == gl.SEPARATE_ATTRIBS && numComponents > maxTfSeparateComponents)
return false; // Per-attribute component es3fTransformFeedbackTests.count exceeded.
totalTfComponents += numComponents;
totalTfAttribs += 1;
}
if (tfMode == gl.SEPARATE_ATTRIBS && totalTfAttribs > maxTfSeparateAttribs)
return false;
if (tfMode == gl.INTERLEAVED_ATTRIBS && totalTfComponents > maxTfInterleavedComponents)
return false;
return true;
};
/**
* @param {string} varyingName
* @param {Array<gluVarTypeUtil.VarTypeComponent>} path
* @return {string}
*/
es3fTransformFeedbackTests.getAttributeName = function(varyingName, path) {
/** @type {string} */ var str = 'a_' + varyingName.substr(/^v_/.test(varyingName) ? 2 : 0);
for (var i = 0; i < path.length; ++i) {
/** @type {string} */ var prefix;
switch (path[i].type) {
case gluVarTypeUtil.VarTypeComponent.s_Type.STRUCT_MEMBER: prefix = '_m'; break;
case gluVarTypeUtil.VarTypeComponent.s_Type.ARRAY_ELEMENT: prefix = '_e'; break;
case gluVarTypeUtil.VarTypeComponent.s_Type.MATRIX_COLUMN: prefix = '_c'; break;
case gluVarTypeUtil.VarTypeComponent.s_Type.VECTOR_COMPONENT: prefix = '_s'; break;
default:
throw new Error('invalid type in the component path.');
}
str += prefix + path[i].index;
}
return str;
};
/**
* original definition:
* static void es3fTransformFeedbackTests.genShaderSources (const es3fTransformFeedbackTests.ProgramSpec& spec, std::string& vertSource, std::string& fragSource, bool pointSizeRequired)
* in place of the std::string references, this function returns those params in an object
*
* @param {es3fTransformFeedbackTests.ProgramSpec} spec
* @param {boolean} pointSizeRequired
* @return {Object.<string, string>}
*/
es3fTransformFeedbackTests.genShaderSources = function(spec, pointSizeRequired) {
var vtx = { str: null };
var frag = { str: null };
var addPointSize = spec.isPointSizeUsed();
vtx.str = '#version 300 es\n' +
'in highp vec4 a_position;\n';
frag.str = '#version 300 es\n' +
'layout(location = 0) out mediump vec4 o_color;\n' +
'uniform highp vec4 u_scale;\n' +
'uniform highp vec4 u_bias;\n';
//vtx.str = 'attribute highp vec4 a_position;\n';
//frag.str = 'uniform highp vec4 u_scale;\n' +
// 'uniform highp vec4 u_bias;\n';
if (addPointSize) {
vtx.str += 'in highp float a_pointSize;\n';
//vtx.str += 'attribute highp float a_pointSize;\n';
}
// Declare attributes.
for (var i = 0; i < spec.getVaryings().length; ++i) {
/** @type {string} */ var name = spec.getVaryings()[i].name;
/** @type {gluVarType.VarType} */ var type = spec.getVaryings()[i].type;
for (var vecIter = new gluVarTypeUtil.VectorTypeIterator(type); !vecIter.end(); vecIter.next()) {
/** @type {gluVarType.VarType} */
var attribType = gluVarTypeUtil.getVarType(type, vecIter.getPath());
/** @type {string} */
var attribName = es3fTransformFeedbackTests.getAttributeName(name, vecIter.getPath());
vtx.str += 'in ' + gluVarType.declareVariable(attribType, attribName) + ';\n';
}
}
// Declare varyings.
for (var ndx = 0; ndx < 2; ++ndx) {
var inout = ndx ? 'in' : 'out';
var shader = ndx ? frag : vtx;
for (var i = 0; i < spec.getStructs().length; ++i) {
var struct = spec.getStructs()[i];
if (struct.hasTypeName()) {
shader.str += gluVarType.declareStructType(struct) + ';\n';
}
}
/** @type {Array<es3fTransformFeedbackTests.Varying>} */ var varyings = spec.getVaryings();
for (var i = 0; i < varyings.length; ++i) {
var varying = varyings[i];
shader.str += es3fTransformFeedbackTests.getInterpolationName(varying.interpolation) +
' ' + inout + ' ' +
gluVarType.declareVariable(varying.type, varying.name) +
';\n';
}
}
vtx.str += '\nvoid main (void)\n {\n' +
'\tgl_Position = a_position;\n';
frag.str += '\nvoid main (void)\n {\n' +
'\thighp vec4 res = vec4(0.0);\n';
if (addPointSize) {
vtx.str += '\tgl_PointSize = a_pointSize;\n';
} else if (pointSizeRequired) {
vtx.str += '\tgl_PointSize = 1.0;\n';
}
for (var i = 0; i < spec.getVaryings().length; ++i) {
var name = spec.getVaryings()[i].name;
var type = spec.getVaryings()[i].type;
for (var vecIter = new gluVarTypeUtil.VectorTypeIterator(type); !vecIter.end(); vecIter.next()) {
/** @type {gluVarType.VarType} */var subType = gluVarTypeUtil.getVarType(type, vecIter.getPath());
var attribName = es3fTransformFeedbackTests.getAttributeName(name, vecIter.getPath());
if (!(
subType.isBasicType() &&
gluShaderUtil.isDataTypeScalarOrVector(subType.getBasicType())
)) throw new Error('Not a scalar or vector.');
// Vertex: assign from attribute.
vtx.str += '\t' + name + vecIter.toString() + ' = ' + attribName + ';\n';
// Fragment: add to res variable.
var scalarSize = gluShaderUtil.getDataTypeScalarSize(subType.getBasicType());
frag.str += '\tres += ';
if (scalarSize == 1) frag.str += 'vec4(' + name + vecIter.toString() + ')';
else if (scalarSize == 2) frag.str += 'vec2(' + name + vecIter.toString() + ').xxyy';
else if (scalarSize == 3) frag.str += 'vec3(' + name + vecIter.toString() + ').xyzx';
else if (scalarSize == 4) frag.str += 'vec4(' + name + vecIter.toString() + ')';
frag.str += ';\n';
}
}
frag.str += '\to_color = res * u_scale + u_bias;\n}\n';
//frag.str += '\tgl_FragColor = res * u_scale + u_bias;\n}\n';
vtx.str += '}\n';
return {
vertSource: vtx.str,
fragSource: frag.str
};
};
/**
* Returns a Shader program
* @param {es3fTransformFeedbackTests.ProgramSpec} spec
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @return {gluShaderProgram.ShaderProgram}
*/
es3fTransformFeedbackTests.createVertexCaptureProgram = function(spec, bufferMode, primitiveType) {
/** @type {Object.<string, string>} */ var source = es3fTransformFeedbackTests.genShaderSources(spec, primitiveType === gluDrawUtil.primitiveType.POINTS /* Is point size required? */);
var programSources = new gluShaderProgram.ProgramSources();
programSources.add(new gluShaderProgram.VertexSource(source.vertSource))
.add(new gluShaderProgram.FragmentSource(source.fragSource))
.add(new gluShaderProgram.TransformFeedbackVaryings(spec.getTransformFeedbackVaryings()))
.add(new gluShaderProgram.TransformFeedbackMode(bufferMode));
return new gluShaderProgram.ShaderProgram(gl, programSources);
};
/**
* @param {Array<es3fTransformFeedbackTests.Attribute>} attributes
* @param {Array<es3fTransformFeedbackTests.Varying>} varyings
* @param {boolean} usePointSize
* @return {number} input stride
*/
es3fTransformFeedbackTests.computeInputLayout = function(attributes, varyings, usePointSize) {
var inputStride = 0;
// Add position
var dataTypeVec4 = gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.precision.PRECISION_HIGHP);
attributes.push(new es3fTransformFeedbackTests.Attribute('a_position', dataTypeVec4, inputStride));
inputStride += 4 * 4; /*sizeof(deUint32)*/
if (usePointSize) {
var dataTypeFloat = gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT, gluShaderUtil.precision.PRECISION_HIGHP);
attributes.push(new es3fTransformFeedbackTests.Attribute('a_pointSize', dataTypeFloat, inputStride));
inputStride += 1 * 4; /*sizeof(deUint32)*/
}
for (var i = 0; i < varyings.length; i++) {
for (var vecIter = new gluVarTypeUtil.VectorTypeIterator(varyings[i].type); !vecIter.end(); vecIter.next()) {
var type = vecIter.getType(); // originally getType() in getVarType() within gluVARTypeUtil.hpp.
var name = es3fTransformFeedbackTests.getAttributeName(varyings[i].name, vecIter.getPath());
attributes.push(new es3fTransformFeedbackTests.Attribute(name, type, inputStride));
inputStride += gluShaderUtil.getDataTypeScalarSize(type.getBasicType()) * 4; /*sizeof(deUint32)*/
}
}
return inputStride;
};
/**
* @param {Array<es3fTransformFeedbackTests.Output>} transformFeedbackOutputs
* @param {Array<es3fTransformFeedbackTests.Attribute>} attributes
* @param {Array<es3fTransformFeedbackTests.Varying>} varyings
* @param {Array<string>} transformFeedbackVaryings
* @param {number} bufferMode
*/
es3fTransformFeedbackTests.computeTransformFeedbackOutputs = function(transformFeedbackOutputs, attributes, varyings, transformFeedbackVaryings, bufferMode) {
/** @type {number} */ var accumulatedSize = 0;
// transformFeedbackOutputs.resize(transformFeedbackVaryings.size());
for (var varNdx = 0; varNdx < transformFeedbackVaryings.length; varNdx++) {
/** @type {string} */ var name = transformFeedbackVaryings[varNdx];
/** @type {number} */ var bufNdx = (bufferMode === gl.SEPARATE_ATTRIBS ? varNdx : 0);
/** @type {number} */ var offset = (bufferMode === gl.SEPARATE_ATTRIBS ? 0 : accumulatedSize);
/** @type {es3fTransformFeedbackTests.Output} */ var output = new es3fTransformFeedbackTests.Output();
output.name = name;
output.bufferNdx = bufNdx;
output.offset = offset;
if (name === 'gl_Position') {
var posIn = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_position');
output.type = posIn.type;
output.inputs.push(posIn);
} else if (name === 'gl_PointSize') {
var sizeIn = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_pointSize');
output.type = sizeIn.type;
output.inputs.push(sizeIn);
} else {
var varName = gluVarTypeUtil.parseVariableName(name);
var varying = es3fTransformFeedbackTests.findAttributeNameEquals(varyings, varName);
var varPath = gluVarTypeUtil.parseTypePath(name, varying.type);
output.type = gluVarTypeUtil.getVarType(varying.type, varPath);
// Add all vectorized attributes as inputs.
for (var iter = new gluVarTypeUtil.VectorTypeIterator(output.type); !iter.end(); iter.next()) {
var fullpath = varPath.concat(iter.getPath());
var attribName = es3fTransformFeedbackTests.getAttributeName(varName, fullpath);
var attrib = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, attribName);
output.inputs.push(attrib);
}
}
transformFeedbackOutputs.push(output);
accumulatedSize += output.type.getScalarSize() * 4; /*sizeof(deUint32)*/
}
};
/**
* @param {es3fTransformFeedbackTests.Attribute} attrib
* @param {ArrayBuffer} buffer
* @param {number} stride
* @param {number} numElements
* @param {deRandom.Random} rnd
*/
es3fTransformFeedbackTests.genAttributeData = function(attrib, buffer, stride, numElements, rnd) {
/** @type {number} */ var elementSize = 4; /*sizeof(deUint32)*/
/** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(attrib.type.getBasicType());
/** @type {boolean} */ var isInt = gluShaderUtil.isDataTypeIntOrIVec(attrib.type.getBasicType());
/** @type {boolean} */ var isUint = gluShaderUtil.isDataTypeUintOrUVec(attrib.type.getBasicType());
/** @type {gluShaderUtil.precision} */ var precision = attrib.type.getPrecision();
/** @type {number} */ var numComps = gluShaderUtil.getDataTypeScalarSize(attrib.type.getBasicType());
for (var elemNdx = 0; elemNdx < numElements; elemNdx++) {
for (var compNdx = 0; compNdx < numComps; compNdx++) {
/** @type {number} */ var offset = attrib.offset + elemNdx * stride + compNdx * elementSize;
if (isFloat) {
var pos = new Float32Array(buffer, offset, 1);
switch (precision) {
case gluShaderUtil.precision.PRECISION_LOWP: pos[0] = 0.25 * rnd.getInt(0, 4); break;
case gluShaderUtil.precision.PRECISION_MEDIUMP: pos[0] = rnd.getFloat(-1e3, 1e3); break;
case gluShaderUtil.precision.PRECISION_HIGHP: pos[0] = rnd.getFloat(-1e5, 1e5); break;
default: throw new Error('Unknown precision: ' + precision);
}
} else if (isInt) {
var pos = new Int32Array(buffer, offset, 1);
switch (precision) {
case gluShaderUtil.precision.PRECISION_LOWP: pos[0] = rnd.getInt(-128, 127); break;
case gluShaderUtil.precision.PRECISION_MEDIUMP: pos[0] = rnd.getInt(-32768, 32767); break;
case gluShaderUtil.precision.PRECISION_HIGHP: pos[0] = rnd.getInt(); break;
default: throw new Error('Unknown precision: ' + precision);
}
} else if (isUint) {
var pos = new Uint32Array(buffer, offset, 1);
switch (precision) {
case gluShaderUtil.precision.PRECISION_LOWP: pos[0] = rnd.getInt(0, 255); break;
case gluShaderUtil.precision.PRECISION_MEDIUMP: pos[0] = rnd.getInt(0, 65535); break;
case gluShaderUtil.precision.PRECISION_HIGHP: pos[0] = Math.abs(rnd.getInt()); break;
default: throw new Error('Unknown precision: ' + precision);
}
}
}
}
};
/**
* @param {Array<es3fTransformFeedbackTests.Attribute>} attributes
* @param {number} numInputs
* @param {number} inputStride
* @param {deRandom.Random} rnd
* @return {ArrayBuffer}
*/
es3fTransformFeedbackTests.genInputData = function(attributes, numInputs, inputStride, rnd) {
var buffer = new ArrayBuffer(numInputs * inputStride);
var position = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_position');
if (!position)
throw new Error('Position attribute not found.');
for (var ndx = 0; ndx < numInputs; ndx++) {
var pos = new Float32Array(buffer, position.offset + inputStride * ndx, 4);
pos[0] = rnd.getFloat(-1.2, 1.2);
pos[1] = rnd.getFloat(-1.2, 1.2);
pos[2] = rnd.getFloat(-1.2, 1.2);
pos[3] = rnd.getFloat(0.1, 2.0);
}
var pointSizePos = es3fTransformFeedbackTests.findAttributeNameEquals(attributes, 'a_pointSize');
if (pointSizePos) {
for (var ndx = 0; ndx < numInputs; ndx++) {
var pos = new Float32Array(buffer, pointSizePos.offset + inputStride * ndx, 1);
pos[0] = rnd.getFloat(1, 8);
}
}
// Random data for rest of components.
for (var i = 0; i < attributes.length; i++) {
if (attributes[i].name != 'a_position' && attributes[i].name != 'a_pointSize')
es3fTransformFeedbackTests.genAttributeData(attributes[i], buffer, inputStride, numInputs, rnd);
}
return buffer;
};
/**
* Returns the number of outputs with the es3fTransformFeedbackTests.count for the Primitives in the Transform Feedback.
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {number} numElements
* @return {number}
*/
es3fTransformFeedbackTests.getTransformFeedbackOutputCount = function(primitiveType, numElements) {
switch (primitiveType) {
case gluDrawUtil.primitiveType.TRIANGLES: return numElements - numElements % 3;
case gluDrawUtil.primitiveType.TRIANGLE_STRIP: return Math.max(0, numElements - 2) * 3;
case gluDrawUtil.primitiveType.TRIANGLE_FAN: return Math.max(0, numElements - 2) * 3;
case gluDrawUtil.primitiveType.LINES: return numElements - numElements % 2;
case gluDrawUtil.primitiveType.LINE_STRIP: return Math.max(0, numElements - 1) * 2;
case gluDrawUtil.primitiveType.LINE_LOOP: return numElements > 1 ? numElements * 2 : 0;
case gluDrawUtil.primitiveType.POINTS: return numElements;
default:
throw new Error('Unrecognized primitiveType ' + primitiveType);
}
};
/**
* Returns a number with the es3fTransformFeedbackTests.count for the Primitives in the Transform Feedback.
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {number} numElements
* @return {number}
*/
es3fTransformFeedbackTests.getTransformFeedbackPrimitiveCount = function(primitiveType, numElements) {
switch (primitiveType) {
case gluDrawUtil.primitiveType.TRIANGLES: return Math.floor(numElements / 3);
case gluDrawUtil.primitiveType.TRIANGLE_STRIP: return Math.max(0, numElements - 2);
case gluDrawUtil.primitiveType.TRIANGLE_FAN: return Math.max(0, numElements - 2);
case gluDrawUtil.primitiveType.LINES: return Math.floor(numElements / 2);
case gluDrawUtil.primitiveType.LINE_STRIP: return Math.max(0, numElements - 1);
case gluDrawUtil.primitiveType.LINE_LOOP: return numElements > 1 ? numElements : 0;
case gluDrawUtil.primitiveType.POINTS: return numElements;
default:
throw new Error('Unrecognized primitiveType ' + primitiveType);
}
};
/**
* Returns the type of Primitive Mode: Triangles for all Triangle Primitive's type and same for Line and Points.
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @return {number} primitiveType
*/
es3fTransformFeedbackTests.getTransformFeedbackPrimitiveMode = function(primitiveType) {
switch (primitiveType) {
case gluDrawUtil.primitiveType.TRIANGLES:
case gluDrawUtil.primitiveType.TRIANGLE_STRIP:
case gluDrawUtil.primitiveType.TRIANGLE_FAN:
return gl.TRIANGLES;
case gluDrawUtil.primitiveType.LINES:
case gluDrawUtil.primitiveType.LINE_STRIP:
case gluDrawUtil.primitiveType.LINE_LOOP:
return gl.LINES;
case gluDrawUtil.primitiveType.POINTS:
return gl.POINTS;
default:
throw new Error('Unrecognized primitiveType ' + primitiveType);
}
};
/**
* Returns the attribute index for a certain primitive type.
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {number} numInputs
* @param {number} outNdx
* @return {number}
*/
es3fTransformFeedbackTests.getAttributeIndex = function(primitiveType, numInputs, outNdx) {
switch (primitiveType) {
case gluDrawUtil.primitiveType.TRIANGLES: return outNdx;
case gluDrawUtil.primitiveType.LINES: return outNdx;
case gluDrawUtil.primitiveType.POINTS: return outNdx;
case gluDrawUtil.primitiveType.TRIANGLE_STRIP: {
/** @type {number} */ var triNdx = outNdx / 3;
/** @type {number} */ var vtxNdx = outNdx % 3;
return (triNdx % 2 != 0 && vtxNdx < 2) ? (triNdx + 1 - vtxNdx) : (triNdx + vtxNdx);
}
case gluDrawUtil.primitiveType.TRIANGLE_FAN:
return (outNdx % 3 != 0) ? (outNdx / 3 + outNdx % 3) : 0;
case gluDrawUtil.primitiveType.LINE_STRIP:
return outNdx / 2 + outNdx % 2;
case gluDrawUtil.primitiveType.LINE_LOOP: {
var inNdx = outNdx / 2 + outNdx % 2;
return inNdx < numInputs ? inNdx : 0;
}
default:
throw new Error('Unrecognized primitiveType ' + primitiveType);
}
};
/**
* @param {gluDrawUtil.primitiveType} primitiveType type number in gluDrawUtil.primitiveType
* @param {es3fTransformFeedbackTests.Output} output
* @param {number} numInputs
* @param {Object} buffers
* @return {boolean} isOk
*/
es3fTransformFeedbackTests.compareTransformFeedbackOutput = function(primitiveType, output, numInputs, buffers) {
/** @type {boolean} */ var isOk = true;
/** @type {number} */ var outOffset = output.offset;
for (var attrNdx = 0; attrNdx < output.inputs.length; attrNdx++) {
/** @type {es3fTransformFeedbackTests.Attribute} */ var attribute = output.inputs[attrNdx];
/** @type {gluShaderUtil.DataType} */ var type = attribute.type.getBasicType();
/** @type {number} */ var numComponents = gluShaderUtil.getDataTypeScalarSize(type);
/** @type {gluShaderUtil.precision} */ var precision = attribute.type.getPrecision();
/** @type {string} */ var scalarType = gluShaderUtil.getDataTypeScalarType(type);
/** @type {number} */ var numOutputs = es3fTransformFeedbackTests.getTransformFeedbackOutputCount(primitiveType, numInputs);
for (var outNdx = 0; outNdx < numOutputs; outNdx++) {
/** @type {number} */ var inNdx = es3fTransformFeedbackTests.getAttributeIndex(primitiveType, numInputs, outNdx);
for (var compNdx = 0; compNdx < numComponents; compNdx++) {
/** @type {boolean} */ var isEqual = false;
if (scalarType === 'float') {
var outBuffer = new Float32Array(buffers.output.buffer, buffers.output.offset + buffers.output.stride * outNdx + outOffset + compNdx * 4, 1);
var inBuffer = new Float32Array(buffers.input.buffer, buffers.input.offset + buffers.input.stride * inNdx + attribute.offset + compNdx * 4, 1);
var difInOut = inBuffer[0] - outBuffer[0];
/* TODO: Original code used ULP comparison for highp and mediump precision. This could cause failures. */
switch (precision) {
case gluShaderUtil.precision.PRECISION_HIGHP: {
isEqual = Math.abs(difInOut) < 0.1;
break;
}
case gluShaderUtil.precision.PRECISION_MEDIUMP: {
isEqual = Math.abs(difInOut) < 0.1;
break;
}
case gluShaderUtil.precision.PRECISION_LOWP: {
isEqual = Math.abs(difInOut) < 0.1;
break;
}
default:
throw new Error('Unknown precision: ' + precision);
}
} else {
var outBuffer = new Uint32Array(buffers.output.buffer, buffers.output.offset + buffers.output.stride * outNdx + outOffset + compNdx * 4, 1);
var inBuffer = new Uint32Array(buffers.input.buffer, buffers.input.offset + buffers.input.stride * inNdx + attribute.offset + compNdx * 4, 1);
isEqual = (inBuffer[0] == outBuffer[0]); // Bit-exact match required for integer types.
}
if (!isEqual) {
bufferedLogToConsole('Mismatch in ' + output.name + ' (' + attribute.name + '), output = ' + outNdx + ', input = ' + inNdx + ', component = ' + compNdx);
isOk = false;
break;
}
}
if (!isOk)
break;
}
if (!isOk)
break;
outOffset += numComponents * 4; /*sizeof(deUint32)*/
}
return isOk;
};
/**
* Returns (for all the draw calls) the type of Primitive Mode, as it calls "es3fTransformFeedbackTests.getTransformFeedbackPrimitiveCount".
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {Array<es3fTransformFeedbackTests.DrawCall>} array Object.<number, boolean>
* @return {number} primCount
*/
es3fTransformFeedbackTests.computeTransformFeedbackPrimitiveCount = function(primitiveType, array) {
/** @type {number} */ var primCount = 0;
for (var i = 0; i < array.length; ++ i) {
if (array[i].transformFeedbackEnabled)
primCount += es3fTransformFeedbackTests.getTransformFeedbackPrimitiveCount(primitiveType, array[i].numElements);
}
return primCount;
};
/**
* @param {number} target
* @param {number} bufferSize
* @param {number} guardSize
*/
es3fTransformFeedbackTests.writeBufferGuard = function(target, bufferSize, guardSize) {
var buffer = new ArrayBuffer(guardSize);
var view = new Uint8Array(buffer);
for (var i = 0; i < guardSize; ++i) view[i] = 0xcd;
gl.bufferSubData(target, bufferSize, buffer);
};
/**
* Verifies guard
* @param {ArrayBuffer} buffer
* @param {number} start
* @return {boolean}
*/
es3fTransformFeedbackTests.verifyGuard = function(buffer, start) {
start = start || 0;
var view = new Uint8Array(buffer, start);
for (var i = 0; i < view.length; i++) {
if (view[i] != 0xcd)
return false;
}
return true;
};
/**
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @constructor
*/
es3fTransformFeedbackTests.TransformFeedbackCase = function(name, desc, bufferMode, primitiveType) {
tcuTestCase.DeqpTest.call(this, name, desc);
this.m_bufferMode = bufferMode;
this.m_primitiveType = primitiveType;
this.m_progSpec = new es3fTransformFeedbackTests.ProgramSpec();
// Derived from es3fTransformFeedbackTests.ProgramSpec in es3fTransformFeedbackTests.init()
this.m_inputStride = 0;
this.m_attributes = []; // vector<es3fTransformFeedbackTests.Attribute>
this.m_transformFeedbackOutputs = []; // vector<es3fTransformFeedbackTests.Output>
this.m_bufferStrides = []; // vector<int>
// GL state.
this.m_program = null; // glu::ShaderProgram
this.m_transformFeedback = null; // glu::TransformFeedback
this.m_outputBuffers = []; // vector<deUint32>
this.m_iterNdx = 0; // int
this.m_testPassed = true;
// State machine
this.m_state = es3fTransformFeedbackTests.State.DRAW;
this.m_verifyStart = null;
this.m_frameWithTf = null;
this.m_frameWithoutTf = null;
this.m_viewportW = 0;
this.m_viewportH = 0;
this.m_viewportX = 0;
this.m_viewportY = 0;
this.m_primitiveQuery = null;
this.m_outputsOk = true;
};
setParentClass(es3fTransformFeedbackTests.TransformFeedbackCase, tcuTestCase.DeqpTest);
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.createVerificationResult = function(retry, result) {
return { retry: retry, result: result };
}
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.dumpShaderText = function() {
var dbgext = gl.getExtension('WEBGL_debug_shaders');
for (var ii = 0; ii < this.m_program.shaders.length; ++ii) {
debug('Shader source ' + ii + ' before translation:')
debug(this.m_program.shaders[ii].info.source);
debug('');
debug('Shader source ' + ii + ' after translation:');
debug(dbgext.getTranslatedShaderSource(this.m_program.shaders[ii].shader));
}
};
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.init = function() {
this.m_program = es3fTransformFeedbackTests.createVertexCaptureProgram(
this.m_progSpec,
this.m_bufferMode,
this.m_primitiveType
);
if (!this.m_program.isOk()) {
// this.dumpShaderText();
var linkFail = this.m_program.shadersOK &&
!this.m_program.getProgramInfo().linkOk;
if (linkFail) {
if (!es3fTransformFeedbackTests.isProgramSupported(this.m_progSpec, this.m_bufferMode)) {
var msg = 'Not Supported. Implementation limits exceeded.';
checkMessage(false, msg);
throw new TestFailedException(msg);
} else if (es3fTransformFeedbackTests.hasArraysInTFVaryings(this.m_progSpec)) {
msg = 'Capturing arrays is not supported (undefined in specification)';
checkMessage(false, msg);
throw new TestFailedException(msg);
} else {
throw new Error('Link failed: ' + this.m_program.getProgramInfo().infoLog);
}
} else {
throw new Error('Compile failed');
}
} else {
// debug('Program is ' +
// (gl.getProgramParameter(this.m_program.getProgram(), gl.LINK_STATUS) ? 'linked' : 'not linked'));
// this.dumpShaderText();
}
// bufferedLogToConsole('Transform feedback varyings: ' + tcu.formatArray(this.m_progSpec.getTransformFeedbackVaryings()));
bufferedLogToConsole('Transform feedback varyings: ' + this.m_progSpec.getTransformFeedbackVaryings());
// Print out transform feedback points reported by GL.
// bufferedLogToConsole('Transform feedback varyings reported by compiler:');
//logTransformFeedbackVaryings(log, gl, this.m_program.getProgram());
// Compute input specification.
this.m_inputStride = es3fTransformFeedbackTests.computeInputLayout(this.m_attributes, this.m_progSpec.getVaryings(), this.m_progSpec.isPointSizeUsed());
// Build list of varyings used in transform feedback.
es3fTransformFeedbackTests.computeTransformFeedbackOutputs(
this.m_transformFeedbackOutputs,
this.m_attributes,
this.m_progSpec.getVaryings(),
this.m_progSpec.getTransformFeedbackVaryings(),
this.m_bufferMode
);
if (!this.m_transformFeedbackOutputs.length) {
throw new Error('transformFeedbackOutputs cannot be empty.');
}
if (this.m_bufferMode == gl.SEPARATE_ATTRIBS) {
for (var i = 0; i < this.m_transformFeedbackOutputs.length; ++i) {
this.m_bufferStrides.push(this.m_transformFeedbackOutputs[i].type.getScalarSize() * 4 /*sizeof(deUint32)*/);
}
} else {
var totalSize = 0;
for (var i = 0; i < this.m_transformFeedbackOutputs.length; ++i) {
totalSize += this.m_transformFeedbackOutputs[i].type.getScalarSize() * 4 /*sizeof(deUint32)*/;
}
this.m_bufferStrides.push(totalSize);
}
this.m_outputBuffers.length = this.m_bufferStrides.length;
for (var i = 0; i < this.m_outputBuffers.length; i++)
this.m_outputBuffers[i] = gl.createBuffer();
this.m_transformFeedback = gl.createTransformFeedback();
this.m_iterNdx = 0;
// this.m_testCtx.setTestResult(QP_TEST_RESULT_PASS, 'Pass');
};
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.deinit = function() {
for (var i = 0; i < this.m_outputBuffers.length; i++)
gl.deleteBuffer(this.m_outputBuffers[i]);
// delete this.m_transformFeedback;
this.m_transformFeedback = null;
// delete this.m_program;
this.m_program = null;
// Clean up state.
this.m_attributes = [];
this.m_transformFeedbackOutputs = [];
this.m_bufferStrides = [];
this.m_inputStride = 0;
};
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.iterate = function() {
var s = es3fTransformFeedbackTests.TransformFeedbackCase.s_iterate;
var numIterations = s.iterations.length;
var seed = deMath.deMathHash(this.m_iterNdx);
switch(this.m_state) {
case es3fTransformFeedbackTests.State.DRAW:
bufferedLogToConsole('Testing ' +
s.testCases[s.iterations[this.m_iterNdx]].length +
' draw calls, (element es3fTransformFeedbackTests.count, TF state): ' +
s.testCases[s.iterations[this.m_iterNdx]]
);
this.draw(s.testCases[s.iterations[this.m_iterNdx]], seed);
this.m_state = es3fTransformFeedbackTests.State.VERIFY;
break;
case es3fTransformFeedbackTests.State.VERIFY:
var verifyResult = this.verify(s.testCases[s.iterations[this.m_iterNdx]]);
if (verifyResult.retry) {
break;
}
this.m_testPassed = verifyResult.result;
this.m_iterNdx += 1;
if (this.m_testPassed && this.m_iterNdx < numIterations) {
this.m_state = es3fTransformFeedbackTests.State.DRAW;
break;
}
// Fall through
case es3fTransformFeedbackTests.State.FINISH:
if (!this.m_testPassed) testFailedOptions('Result comparison failed for iteration ' + s.iterations[this.m_iterNdx - 1], false);
else testPassedOptions('Result comparison succeeded', true);
return tcuTestCase.IterateResult.STOP;
}
return tcuTestCase.IterateResult.CONTINUE;
};
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.draw = function(calls, seed) {
var _min = function(x, y) { return x < y ? x : y; };
var rnd = new deRandom.Random(seed);
var numInputs = 0;
var numOutputs = 0;
var width = gl.drawingBufferWidth;
var height = gl.drawingBufferHeight;
this.m_viewportW = _min(es3fTransformFeedbackTests.VIEWPORT_WIDTH, width);
this.m_viewportH = _min(es3fTransformFeedbackTests.VIEWPORT_HEIGHT, height);
this.m_viewportX = rnd.getInt(0, width - this.m_viewportW);
this.m_viewportY = rnd.getInt(0, height - this.m_viewportH);
this.m_frameWithTf = new tcuSurface.Surface(this.m_viewportW, this.m_viewportH); // tcu::Surface
this.m_frameWithoutTf = new tcuSurface.Surface(this.m_viewportW, this.m_viewportH); // tcu::Surface
this.m_primitiveQuery = gl.createQuery();
this.m_outputsOk = true;
// Compute totals.
for (var i = 0; i < calls.length; ++i) {
var call = calls[i];
numInputs += call.numElements;
numOutputs += call.transformFeedbackEnabled ? es3fTransformFeedbackTests.getTransformFeedbackOutputCount(this.m_primitiveType, call.numElements) : 0;
}
// Input data.
var inputData = es3fTransformFeedbackTests.genInputData(this.m_attributes, numInputs, this.m_inputStride, rnd);
gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.m_transformFeedback);
// Allocate storage for transform feedback output buffers and bind to targets.
for (var bufNdx = 0; bufNdx < this.m_outputBuffers.length; ++bufNdx) {
var buffer = this.m_outputBuffers[bufNdx]; // deUint32
var stride = this.m_bufferStrides[bufNdx]; // int
var target = bufNdx; // int
var size = stride * numOutputs; // int
var guardSize = stride * es3fTransformFeedbackTests.BUFFER_GUARD_MULTIPLIER; // int
var usage = gl.DYNAMIC_READ; // const deUint32
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer);
gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, size + guardSize, usage);
es3fTransformFeedbackTests.writeBufferGuard(gl.TRANSFORM_FEEDBACK_BUFFER, size, guardSize);
// \todo [2012-07-30 pyry] glBindBufferRange()?
gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, target, buffer);
}
var attribBuffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, attribBuffer);
gl.bufferData(gl.ARRAY_BUFFER, inputData, gl.STATIC_DRAW);
// Setup attributes.
for (var i = 0; i < this.m_attributes.length; ++i) {
var attrib = this.m_attributes[i];
var loc = gl.getAttribLocation(this.m_program.getProgram(), attrib.name);
/** @type {string} */
var scalarType = gluShaderUtil.getDataTypeScalarType(attrib.type.getBasicType());
/** @type {number} */
var numComponents = gluShaderUtil.getDataTypeScalarSize(attrib.type.getBasicType());
if (loc >= 0) {
gl.enableVertexAttribArray(loc);
switch (scalarType) {
case 'float':
gl.vertexAttribPointer(loc, numComponents, gl.FLOAT, false, this.m_inputStride, attrib.offset); break;
case 'int':
gl.vertexAttribIPointer(loc, numComponents, gl.INT, this.m_inputStride, attrib.offset); break;
case 'uint':
gl.vertexAttribIPointer(loc, numComponents, gl.UNSIGNED_INT, this.m_inputStride, attrib.offset); break;
}
}
}
// Setup viewport.
gl.viewport(this.m_viewportX, this.m_viewportY, this.m_viewportW, this.m_viewportH);
// Setup program.
gl.useProgram(this.m_program.getProgram());
gl.uniform4fv(
gl.getUniformLocation(this.m_program.getProgram(), 'u_scale'),
[0.01, 0.01, 0.01, 0.01]
);
gl.uniform4fv(
gl.getUniformLocation(this.m_program.getProgram(), 'u_bias'),
[0.5, 0.5, 0.5, 0.5]
);
// Enable query.
gl.beginQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, this.m_primitiveQuery);
// Draw
var offset = 0;
var tfEnabled = true;
gl.clear(gl.COLOR_BUFFER_BIT);
var tfPrimitiveMode = es3fTransformFeedbackTests.getTransformFeedbackPrimitiveMode(this.m_primitiveType);
gl.beginTransformFeedback(tfPrimitiveMode);
for (var i = 0; i < calls.length; ++i) {
var call = calls[i];
// Pause or resume transform feedback if necessary.
if (call.transformFeedbackEnabled != tfEnabled) {
if (call.transformFeedbackEnabled)
gl.resumeTransformFeedback();
else
gl.pauseTransformFeedback();
tfEnabled = call.transformFeedbackEnabled;
}
gl.drawArrays(gluDrawUtil.getPrimitiveGLType(gl, this.m_primitiveType), offset, call.numElements);
offset += call.numElements;
}
// Resume feedback before finishing it.
if (!tfEnabled)
gl.resumeTransformFeedback();
gl.endTransformFeedback();
gl.endQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
// Check and log query status right after submit
var query = this.m_primitiveQuery;
var available = gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
if (available) {
this.m_testPassed = false;
this.m_state = es3fTransformFeedbackTests.State.FINISH;
testFailedOptions('Transform feedback query result must not be available the same frame as they are issued.', true);
}
// Compare result buffers.
for (var bufferNdx = 0; bufferNdx < this.m_outputBuffers.length; ++bufferNdx) {
var stride = this.m_bufferStrides[bufferNdx]; // int
var size = stride * numOutputs; // int
var guardSize = stride * es3fTransformFeedbackTests.BUFFER_GUARD_MULTIPLIER; // int
var buffer = new ArrayBuffer(size + guardSize); // const void*
// Bind buffer for reading.
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, this.m_outputBuffers[bufferNdx]);
gl.getBufferSubData(gl.TRANSFORM_FEEDBACK_BUFFER, 0, new Uint8Array(buffer));
// Verify all output variables that are written to this buffer.
for (var i = 0; i < this.m_transformFeedbackOutputs.length; ++i) {
var out = this.m_transformFeedbackOutputs[i];
if (out.bufferNdx != bufferNdx)
continue;
var inputOffset = 0;
var outputOffset = 0;
// Process all draw calls and check ones with transform feedback enabled
for (var callNdx = 0; callNdx < calls.length; ++callNdx) {
var call = calls[callNdx];
if (call.transformFeedbackEnabled) {
var inputPtr = inputData[0] + inputOffset * this.m_inputStride; // const deUint8*
var outputPtr = outputOffset * stride; // const deUint8*
if (!es3fTransformFeedbackTests.compareTransformFeedbackOutput(this.m_primitiveType, out, call.numElements, {
input: {
buffer: inputData,
offset: inputOffset * this.m_inputStride,
stride: this.m_inputStride
},
output: {
buffer: buffer,
offset: outputOffset * stride,
stride: stride
}
})) {
this.m_outputsOk = false;
break;
}
}
inputOffset += call.numElements;
outputOffset += call.transformFeedbackEnabled ? es3fTransformFeedbackTests.getTransformFeedbackOutputCount(this.m_primitiveType, call.numElements) : 0;
}
}
// Verify guardband.
if (!es3fTransformFeedbackTests.verifyGuard(buffer, size)) {
bufferedLogToConsole('Error: Transform feedback buffer overrun detected');
this.m_outputsOk = false;
}
}
};
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.verify = function(calls) {
// Check status after mapping buffers.
var mustBeReady = this.m_outputBuffers.length > 0; // Mapping buffer forces synchronization. // const bool
var expectedCount = es3fTransformFeedbackTests.computeTransformFeedbackPrimitiveCount(this.m_primitiveType, calls); // const int
var available = /** @type {boolean} */ (gl.getQueryParameter(this.m_primitiveQuery, gl.QUERY_RESULT_AVAILABLE));
var verify_offset = 0;
var queryOk = true;
if (!available) {
if (!this.m_verifyStart)
this.m_verifyStart = new Date();
else {
var current = new Date();
var elapsedTime = 0.001 * (current.getTime() - this.m_verifyStart.getTime());
if (elapsedTime > es3fTransformFeedbackTests.MAX_VERIFY_WAIT) {
testFailed('Query result not available after ' + elapsedTime + ' seconds.');
this.m_state = es3fTransformFeedbackTests.State.FINISH;
return this.createVerificationResult(false, false);
}
}
return this.createVerificationResult(true, false);
}
var numPrimitives = /** @type {number} */ (gl.getQueryParameter(this.m_primitiveQuery, gl.QUERY_RESULT));
if (!mustBeReady && available == false)
bufferedLogToConsole('ERROR: gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN result not available after mapping buffers!');
bufferedLogToConsole('gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = ' + numPrimitives);
if (numPrimitives != expectedCount) {
queryOk = false;
bufferedLogToConsole('ERROR: Expected ' + expectedCount + ' primitives!');
}
// Clear transform feedback state.
gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
for (var bufNdx = 0; bufNdx < this.m_outputBuffers.length; ++bufNdx) {
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, null);
gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, bufNdx, null);
}
gl.bindBuffer(gl.ARRAY_BUFFER, null);
// Read back rendered image.
this.m_frameWithTf.readViewport(gl, [this.m_viewportX, this.m_viewportY, this.m_viewportW, this.m_viewportH]);
// Render without transform feedback.
gl.clear(gl.COLOR_BUFFER_BIT);
for (var i = 0; i < calls.length; ++i) {
var call = calls[i];
gl.drawArrays(gluDrawUtil.getPrimitiveGLType(gl, this.m_primitiveType), verify_offset, call.numElements);
verify_offset += call.numElements;
}
this.m_frameWithoutTf.readViewport(gl, [this.m_viewportX, this.m_viewportY, this.m_viewportW, this.m_viewportH]);
// Compare images with and without transform feedback.
var imagesOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', this.m_frameWithoutTf, this.m_frameWithTf, [1, 1, 1, 1], tcuImageCompare.CompareLogMode.ON_ERROR);
if (imagesOk)
bufferedLogToConsole('Rendering result comparison between TF enabled and TF disabled passed.');
else
bufferedLogToConsole('ERROR: Rendering result comparison between TF enabled and TF disabled failed!');
return this.createVerificationResult(false, this.m_outputsOk && imagesOk && queryOk);
};
es3fTransformFeedbackTests.dc = function(numElements, tfEnabled) {
return new es3fTransformFeedbackTests.DrawCall(numElements, tfEnabled);
};
// static data
es3fTransformFeedbackTests.TransformFeedbackCase.s_iterate = {
testCases: {
elemCount1: [es3fTransformFeedbackTests.dc(1, true)],
elemCount2: [es3fTransformFeedbackTests.dc(2, true)],
elemCount3: [es3fTransformFeedbackTests.dc(3, true)],
elemCount4: [es3fTransformFeedbackTests.dc(4, true)],
elemCount123: [es3fTransformFeedbackTests.dc(123, true)],
basicPause1: [es3fTransformFeedbackTests.dc(64, true), es3fTransformFeedbackTests.dc(64, false), es3fTransformFeedbackTests.dc(64, true)],
basicPause2: [es3fTransformFeedbackTests.dc(13, true), es3fTransformFeedbackTests.dc(5, true), es3fTransformFeedbackTests.dc(17, false),
es3fTransformFeedbackTests.dc(3, true), es3fTransformFeedbackTests.dc(7, false)],
startPaused: [es3fTransformFeedbackTests.dc(123, false), es3fTransformFeedbackTests.dc(123, true)],
random1: [es3fTransformFeedbackTests.dc(65, true), es3fTransformFeedbackTests.dc(135, false), es3fTransformFeedbackTests.dc(74, true),
es3fTransformFeedbackTests.dc(16, false), es3fTransformFeedbackTests.dc(226, false), es3fTransformFeedbackTests.dc(9, true),
es3fTransformFeedbackTests.dc(174, false)],
random2: [es3fTransformFeedbackTests.dc(217, true), es3fTransformFeedbackTests.dc(171, true), es3fTransformFeedbackTests.dc(147, true),
es3fTransformFeedbackTests.dc(152, false), es3fTransformFeedbackTests.dc(55, true)]
},
iterations: [
'elemCount1', 'elemCount2', 'elemCount3', 'elemCount4', 'elemCount123',
'basicPause1', 'basicPause2', 'startPaused',
'random1', 'random2'
]
};
es3fTransformFeedbackTests.hasArraysInTFVaryings = function(spec) {
for (var i = 0; i < spec.getTransformFeedbackVaryings().length; ++i) {
var tfVar = spec.getTransformFeedbackVaryings()[i];
var varName = gluVarTypeUtil.parseVariableName(tfVar);
var attr = es3fTransformFeedbackTests.findAttributeNameEquals(spec.getVaryings(), varName);
if (attr && attr.type.isArrayType())
return true;
}
return false;
};
/** es3fTransformFeedbackTests.PositionCase
* @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @constructor
*/
es3fTransformFeedbackTests.PositionCase = function(name, desc, bufferMode, primitiveType) {
es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
this.m_progSpec.addTransformFeedbackVarying('gl_Position');
};
setParentClass(es3fTransformFeedbackTests.PositionCase, es3fTransformFeedbackTests.TransformFeedbackCase);
/** es3fTransformFeedbackTests.PointSizeCase
* @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @constructor
*/
es3fTransformFeedbackTests.PointSizeCase = function(name, desc, bufferMode, primitiveType) {
es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
this.m_progSpec.addTransformFeedbackVarying('gl_PointSize');
};
setParentClass(es3fTransformFeedbackTests.PointSizeCase, es3fTransformFeedbackTests.TransformFeedbackCase);
/** es3fTransformFeedbackTests.BasicTypeCase
* @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {gluShaderUtil.DataType} type
* @param {gluShaderUtil.precision} precision
* @param {es3fTransformFeedbackTests.interpolation} interpolation enum number in this javascript
* @constructor
*/
es3fTransformFeedbackTests.BasicTypeCase = function(name, desc, bufferMode, primitiveType, type, precision, interpolation) {
es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
this.m_progSpec.addVarying('v_varA', gluVarType.newTypeBasic(type, precision), interpolation);
this.m_progSpec.addVarying('v_varB', gluVarType.newTypeBasic(type, precision), interpolation);
this.m_progSpec.addTransformFeedbackVarying('v_varA');
this.m_progSpec.addTransformFeedbackVarying('v_varB');
};
setParentClass(es3fTransformFeedbackTests.BasicTypeCase, es3fTransformFeedbackTests.TransformFeedbackCase);
/** es3fTransformFeedbackTests.BasicArrayCase
* @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {gluShaderUtil.DataType} type
* @param {gluShaderUtil.precision} precision
* @param {es3fTransformFeedbackTests.interpolation} interpolation enum number in this javascript
* @constructor
*/
es3fTransformFeedbackTests.BasicArrayCase = function(name, desc, bufferMode, primitiveType, type, precision, interpolation) {
es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
if (gluShaderUtil.isDataTypeMatrix(type) || this.m_bufferMode === gl.SEPARATE_ATTRIBS) {
// note For matrix types we need to use reduced array sizes or otherwise we will exceed maximum attribute (16)
// or transform feedback component es3fTransformFeedbackTests.count (64).
// On separate attribs mode maximum component es3fTransformFeedbackTests.count per varying is 4.
this.m_progSpec.addVarying('v_varA', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 1), interpolation);
this.m_progSpec.addVarying('v_varB', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 2), interpolation);
} else {
this.m_progSpec.addVarying('v_varA', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 3), interpolation);
this.m_progSpec.addVarying('v_varB', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 4), interpolation);
}
this.m_progSpec.addTransformFeedbackVarying('v_varA');
this.m_progSpec.addTransformFeedbackVarying('v_varB');
};
setParentClass(es3fTransformFeedbackTests.BasicArrayCase, es3fTransformFeedbackTests.TransformFeedbackCase);
/** es3fTransformFeedbackTests.ArrayElementCase
* @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {gluShaderUtil.DataType} type
* @param {gluShaderUtil.precision} precision
* @param {es3fTransformFeedbackTests.interpolation} interpolation enum number in this javascript
* @constructor
*/
es3fTransformFeedbackTests.ArrayElementCase = function(name, desc, bufferMode, primitiveType, type, precision, interpolation) {
es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
this.m_progSpec.addVarying('v_varA', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 3), interpolation);
this.m_progSpec.addVarying('v_varB', gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), 4), interpolation);
this.m_progSpec.addTransformFeedbackVarying('v_varA[1]');
this.m_progSpec.addTransformFeedbackVarying('v_varB[0]');
this.m_progSpec.addTransformFeedbackVarying('v_varB[3]');
};
setParentClass(es3fTransformFeedbackTests.ArrayElementCase, es3fTransformFeedbackTests.TransformFeedbackCase);
/** es3fTransformFeedbackTests.RandomCase
* @extends {es3fTransformFeedbackTests.TransformFeedbackCase}
* @param {string} name
* @param {string} desc
* @param {number} bufferMode
* @param {gluDrawUtil.primitiveType} primitiveType GLenum that specifies what kind of primitive is
* @param {number} seed
* @constructor
*/
es3fTransformFeedbackTests.RandomCase = function(name, desc, bufferMode, primitiveType, seed) {
es3fTransformFeedbackTests.TransformFeedbackCase.call(this, name, desc, bufferMode, primitiveType);
};
setParentClass(es3fTransformFeedbackTests.RandomCase, es3fTransformFeedbackTests.TransformFeedbackCase);
es3fTransformFeedbackTests.RandomCase.prototype.init = function() {
/** @type {number} */
var seed = /*deString.deStringHash(getName()) ^ */ deMath.deMathHash(this.m_iterNdx);
/** @type {Array<gluShaderUtil.DataType>} */
var typeCandidates = [
gluShaderUtil.DataType.FLOAT,
gluShaderUtil.DataType.FLOAT_VEC2,
gluShaderUtil.DataType.FLOAT_VEC3,
gluShaderUtil.DataType.FLOAT_VEC4,
gluShaderUtil.DataType.INT,
gluShaderUtil.DataType.INT_VEC2,
gluShaderUtil.DataType.INT_VEC3,
gluShaderUtil.DataType.INT_VEC4,
gluShaderUtil.DataType.UINT,
gluShaderUtil.DataType.UINT_VEC2,
gluShaderUtil.DataType.UINT_VEC3,
gluShaderUtil.DataType.UINT_VEC4,
gluShaderUtil.DataType.FLOAT_MAT2,
gluShaderUtil.DataType.FLOAT_MAT2X3,
gluShaderUtil.DataType.FLOAT_MAT2X4,
gluShaderUtil.DataType.FLOAT_MAT3X2,
gluShaderUtil.DataType.FLOAT_MAT3,
gluShaderUtil.DataType.FLOAT_MAT3X4,
gluShaderUtil.DataType.FLOAT_MAT4X2,
gluShaderUtil.DataType.FLOAT_MAT4X3,
gluShaderUtil.DataType.FLOAT_MAT4
];
/** @type {Array<gluShaderUtil.precision>} */
var precisions = [
gluShaderUtil.precision.PRECISION_LOWP,
gluShaderUtil.precision.PRECISION_MEDIUMP,
gluShaderUtil.precision.PRECISION_HIGHP
];
var interpModes = [{name: 'smooth', interp: es3fTransformFeedbackTests.interpolation.SMOOTH}, {name: 'flat', interp: es3fTransformFeedbackTests.interpolation.FLAT}, {name: 'centroid', interp: es3fTransformFeedbackTests.interpolation.CENTROID}
];
/** @type {number} */ var maxAttributeVectors = 16;
//** @type {number} */ var maxTransformFeedbackComponents = 64; // note It is enough to limit attribute set size.
/** @type {boolean} */ var isSeparateMode = (this.m_bufferMode === gl.SEPARATE_ATTRIBS);
/** @type {number} */ var maxTransformFeedbackVars = isSeparateMode ? 4 : maxAttributeVectors;
/** @type {number} */ var arrayWeight = 0.3;
/** @type {number} */ var positionWeight = 0.7;
/** @type {number} */ var pointSizeWeight = 0.1;
/** @type {number} */ var captureFullArrayWeight = 0.5;
/** @type {deRandom.Random} */
var rnd = new deRandom.Random(seed);
/** @type {boolean} */ var usePosition = rnd.getFloat() < positionWeight;
/** @type {boolean} */ var usePointSize = rnd.getFloat() < pointSizeWeight;
/** @type {number} */ var numAttribVectorsToUse = rnd.getInt(
1, maxAttributeVectors - 1/*position*/ - (usePointSize ? 1 : 0)
);
/** @type {number} */ var numAttributeVectors = 0;
/** @type {number} */ var varNdx = 0;
// Generate varyings.
while (numAttributeVectors < numAttribVectorsToUse) {
/** @type {number} */
var maxVecs = isSeparateMode ? Math.min(2 /*at most 2*mat2*/, numAttribVectorsToUse - numAttributeVectors) : numAttribVectorsToUse - numAttributeVectors;
/** @type {gluShaderUtil.DataType} */
var begin = typeCandidates[0];
/** @type {number} */
var endCandidates = begin + (
maxVecs >= 4 ? 21 : (
maxVecs >= 3 ? 18 : (
maxVecs >= 2 ? (isSeparateMode ? 13 : 15) : 12
)
)
);
/** @type {gluShaderUtil.DataType} */
var end = typeCandidates[endCandidates];
/** @type {gluShaderUtil.DataType} */
var type = rnd.choose(typeCandidates)[0];
/** @type {gluShaderUtil.precision} */
var precision = rnd.choose(precisions)[0];
/** @type {es3fTransformFeedbackTests.interpolation} */
var interp = (type === gluShaderUtil.DataType.FLOAT) ?
rnd.choose(interpModes)[0].interp :
es3fTransformFeedbackTests.interpolation.FLAT;
/** @type {number} */
var numVecs = gluShaderUtil.isDataTypeMatrix(type) ? gluShaderUtil.getDataTypeMatrixNumColumns(type) : 1;
/** @type {number} */
var numComps = gluShaderUtil.getDataTypeScalarSize(type);
/** @type {number} */
var maxArrayLen = Math.max(1, isSeparateMode ? (4 / numComps) : (maxVecs / numVecs));
/** @type {boolean} */
var useArray = rnd.getFloat() < arrayWeight;
/** @type {number} */
var arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 1;
/** @type {string} */
var name = 'v_var' + varNdx;
if (useArray)
this.m_progSpec.addVarying(name, gluVarType.newTypeArray(gluVarType.newTypeBasic(type, precision), arrayLen), interp);
else
this.m_progSpec.addVarying(name, gluVarType.newTypeBasic(type, precision), interp);
numAttributeVectors += arrayLen * numVecs;
varNdx += 1;
}
// Generate transform feedback candidate set.
/** @type {Array<string>} */ var tfCandidates = [];
if (usePosition) tfCandidates.push('gl_Position');
if (usePointSize) tfCandidates.push('gl_PointSize');
for (var ndx = 0; ndx < varNdx; ndx++) {
/** @type {es3fTransformFeedbackTests.Varying} */
var varying = this.m_progSpec.getVaryings()[ndx];
if (varying.type.isArrayType()) {
/** @type {boolean} */
var captureFull = rnd.getFloat() < captureFullArrayWeight;
if (captureFull) {
tfCandidates.push(varying.name);
} else {
/** @type {number} */
var numElem = varying.type.getArraySize();
for (var elemNdx = 0; elemNdx < numElem; elemNdx++)
tfCandidates.push(varying.name + '[' + elemNdx + ']');
}
} else
tfCandidates.push(varying.name);
}
// Pick random selection.
var tfVaryings = [];
rnd.choose(tfCandidates, tfVaryings, Math.min(tfCandidates.length, maxTransformFeedbackVars));
rnd.shuffle(tfVaryings);
for (var i = 0; i < tfVaryings.length; i++)
this.m_progSpec.addTransformFeedbackVarying(tfVaryings[i]);
es3fTransformFeedbackTests.TransformFeedbackCase.prototype.init.call(this);
};
/**
* Creates the test in order to be executed
**/
es3fTransformFeedbackTests.init = function() {
/** @const @type {tcuTestCase.DeqpTest} */
var testGroup = tcuTestCase.runner.testCases;
var bufferModes = [{name: 'separate', mode: gl.SEPARATE_ATTRIBS}, {name: 'interleaved', mode: gl.INTERLEAVED_ATTRIBS}
];
var primitiveTypes = [{name: 'points', type: gluDrawUtil.primitiveType.POINTS}, {name: 'lines', type: gluDrawUtil.primitiveType.LINES}, {name: 'triangles', type: gluDrawUtil.primitiveType.TRIANGLES}
];
/** @type {Array<gluShaderUtil.DataType>} */
var basicTypes = [
gluShaderUtil.DataType.FLOAT,
gluShaderUtil.DataType.FLOAT_VEC2,
gluShaderUtil.DataType.FLOAT_VEC3,
gluShaderUtil.DataType.FLOAT_VEC4,
gluShaderUtil.DataType.FLOAT_MAT2,
gluShaderUtil.DataType.FLOAT_MAT2X3,
gluShaderUtil.DataType.FLOAT_MAT2X4,
gluShaderUtil.DataType.FLOAT_MAT3X2,
gluShaderUtil.DataType.FLOAT_MAT3,
gluShaderUtil.DataType.FLOAT_MAT3X4,
gluShaderUtil.DataType.FLOAT_MAT4X2,
gluShaderUtil.DataType.FLOAT_MAT4X3,
gluShaderUtil.DataType.FLOAT_MAT4,
gluShaderUtil.DataType.INT,
gluShaderUtil.DataType.INT_VEC2,
gluShaderUtil.DataType.INT_VEC3,
gluShaderUtil.DataType.INT_VEC4,
gluShaderUtil.DataType.UINT,
gluShaderUtil.DataType.UINT_VEC2,
gluShaderUtil.DataType.UINT_VEC3,
gluShaderUtil.DataType.UINT_VEC4
];
/** @type {Array<gluShaderUtil.precision>} */
var precisions = [
gluShaderUtil.precision.PRECISION_LOWP,
gluShaderUtil.precision.PRECISION_MEDIUMP,
gluShaderUtil.precision.PRECISION_HIGHP
// glsUBC.UniformFlags.PRECISION_LOW,
// glsUBC.UniformFlags.PRECISION_MEDIUM,
// glsUBC.UniformFlags.PRECISION_HIGH
];
var interpModes = [{name: 'smooth', interp: es3fTransformFeedbackTests.interpolation.SMOOTH}, {name: 'flat', interp: es3fTransformFeedbackTests.interpolation.FLAT}, {name: 'centroid', interp: es3fTransformFeedbackTests.interpolation.CENTROID}
];
// .position
/** @type {tcuTestCase.DeqpTest} */
var positionGroup = tcuTestCase.newTest('position', 'gl_Position capture using transform feedback');
testGroup.addChild(positionGroup);
for (var primitiveType = 0; primitiveType < primitiveTypes.length; primitiveType++) {
for (var bufferMode = 0; bufferMode < bufferModes.length; bufferMode++) {
/** @type {string} */
var name = primitiveTypes[primitiveType].name + '_' + bufferModes[bufferMode].name;
positionGroup.addChild(new es3fTransformFeedbackTests.PositionCase(
name,
'',
bufferModes[bufferMode].mode,
primitiveTypes[primitiveType].type
));
}
}
// .point_size
/** @type {tcuTestCase.DeqpTest} */ var pointSizeGroup = tcuTestCase.newTest('point_size', 'gl_PointSize capture using transform feedback');
testGroup.addChild(pointSizeGroup);
for (var primitiveType = 0; primitiveType < primitiveTypes.length; primitiveType++) {
for (var bufferMode = 0; bufferMode < bufferModes.length; bufferMode++) {
var name = primitiveTypes[primitiveType].name + '_' + bufferModes[bufferMode].name;
pointSizeGroup.addChild(new es3fTransformFeedbackTests.PointSizeCase(
name,
'',
bufferModes[bufferMode].mode,
primitiveTypes[primitiveType].type
));
}
}
// .basic_type
for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
/** @type {number} */
var bufferMode = bufferModes[bufferModeNdx].mode;
for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
/** @type {tcuTestCase.DeqpTest} */
var primitiveGroup = tcuTestCase.newTest(
'basic_types.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
'Basic types in transform feedback');
/** @type {number} */
var primitiveType = primitiveTypes[primitiveTypeNdx].type;
testGroup.addChild(primitiveGroup);
for (var typeNdx = 0; typeNdx < basicTypes.length; typeNdx++) {
/** @type {gluShaderUtil.DataType} */
var type = basicTypes[typeNdx];
/** @type {boolean} */
var isFloat = gluShaderUtil.getDataTypeScalarType(type) == gluShaderUtil.DataType.FLOAT;
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
/** @type {gluShaderUtil.precision} */
var precision = precisions[precNdx];
var name = gluShaderUtil.getPrecisionName(precision) + '_' + gluShaderUtil.getDataTypeName(type);
primitiveGroup.addChild(new es3fTransformFeedbackTests.BasicTypeCase(
name,
'',
bufferMode,
primitiveType,
type,
precision,
isFloat ? es3fTransformFeedbackTests.interpolation.SMOOTH : es3fTransformFeedbackTests.interpolation.FLAT
));
}
}
}
}
// .array
for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
var bufferMode = bufferModes[bufferModeNdx].mode;
for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
var primitiveGroup = tcuTestCase.newTest(
'array.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
'Capturing whole array in TF');
/** @type {number} */
var primitiveType = primitiveTypes[primitiveTypeNdx].type;
testGroup.addChild(primitiveGroup);
for (var typeNdx = 0; typeNdx < basicTypes.length; typeNdx++) {
var type = basicTypes[typeNdx];
var isFloat = gluShaderUtil.getDataTypeScalarType(type) == gluShaderUtil.DataType.FLOAT;
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
var precision = precisions[precNdx];
var name = gluShaderUtil.getPrecisionName(precision) + '_' + gluShaderUtil.getDataTypeName(type);
primitiveGroup.addChild(new es3fTransformFeedbackTests.BasicArrayCase(
name,
'',
bufferMode,
primitiveType,
type,
precision,
isFloat ? es3fTransformFeedbackTests.interpolation.SMOOTH : es3fTransformFeedbackTests.interpolation.FLAT
));
}
}
}
}
// .array_element
for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
var bufferMode = bufferModes[bufferModeNdx].mode;
for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
var primitiveGroup = tcuTestCase.newTest(
'array_element.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
'Capturing single array element in TF');
var primitiveType = primitiveTypes[primitiveTypeNdx].type;
testGroup.addChild(primitiveGroup);
for (var typeNdx = 0; typeNdx < basicTypes.length; typeNdx++) {
var type = basicTypes[typeNdx];
var isFloat = gluShaderUtil.getDataTypeScalarType(type) == gluShaderUtil.DataType.FLOAT;
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
var precision = precisions[precNdx];
var name = gluShaderUtil.getPrecisionName(precision) + '_' + gluShaderUtil.getDataTypeName(type);
primitiveGroup.addChild(new es3fTransformFeedbackTests.ArrayElementCase(
name,
'',
bufferMode,
primitiveType,
type,
precision,
isFloat ? es3fTransformFeedbackTests.interpolation.SMOOTH : es3fTransformFeedbackTests.interpolation.FLAT
));
}
}
}
}
// .interpolation
for (var modeNdx = 0; modeNdx < interpModes.length; modeNdx++) {
var interp = interpModes[modeNdx].interp;
var modeGroup = tcuTestCase.newTest(
'interpolation.' + interpModes[modeNdx].name,
'Different interpolation modes in transform feedback varyings');
testGroup.addChild(modeGroup);
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
var precision = precisions[precNdx];
for (var primitiveType = 0; primitiveType < primitiveTypes.length; primitiveType++) {
for (var bufferMode = 0; bufferMode < bufferModes.length; bufferMode++) {
var name = (
gluShaderUtil.getPrecisionName(precision) +
'_vec4_' + primitiveTypes[primitiveType].name +
'_' + bufferModes[bufferMode].name
);
modeGroup.addChild(new es3fTransformFeedbackTests.BasicTypeCase(
name,
'',
bufferModes[bufferMode].mode,
primitiveTypes[primitiveType].type,
gluShaderUtil.DataType.FLOAT_VEC4,
precision,
interp
));
}
}
}
}
// .random
for (var bufferModeNdx = 0; bufferModeNdx < bufferModes.length; bufferModeNdx++) {
/** @type {number} */
var bufferMode = bufferModes[bufferModeNdx].mode;
for (var primitiveTypeNdx = 0; primitiveTypeNdx < primitiveTypes.length; primitiveTypeNdx++) {
var primitiveGroup = tcuTestCase.newTest(
'random.' + bufferModes[bufferModeNdx].name + '.' + primitiveTypes[primitiveTypeNdx].name,
'Randomized transform feedback cases');
/** @type {number} */
var primitiveType = primitiveTypes[primitiveTypeNdx].type;
testGroup.addChild(primitiveGroup);
for (var ndx = 0; ndx < 10; ndx++) {
/** @type {number} */
var seed = deMath.deMathHash(bufferMode) ^ deMath.deMathHash(primitiveType) ^ deMath.deMathHash(ndx);
primitiveGroup.addChild(new es3fTransformFeedbackTests.RandomCase(
(ndx + 1).toString(),
'',
bufferMode,
primitiveType,
seed
));
}
}
}
};
/**
* Create and execute the test cases
*/
es3fTransformFeedbackTests.run = function(context, range) {
gl = context;
var testName = 'transform_feedback';
var testDescription = 'Transform Feedback Tests';
var state = tcuTestCase.runner;
state.testName = testName;
state.testCases = tcuTestCase.newTest(testName, testDescription, null);
//Set up name and description of this test series.
setCurrentTestName(testName);
description(testDescription);
try {
es3fTransformFeedbackTests.init();
if (range)
state.setRange(range);
tcuTestCase.runTestCases();
} catch (err) {
bufferedLogToConsole(err);
tcuTestCase.runner.terminate();
}
};
});