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('modules.shared.glsShaderLibraryCase');
goog.require('framework.common.tcuTestCase');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');
goog.scope(function() {
var glsShaderLibraryCase = modules.shared.glsShaderLibraryCase;
var tcuTestCase = framework.common.tcuTestCase;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluDrawUtil = framework.opengl.gluDrawUtil;
/** @const @type {number} */ glsShaderLibraryCase.VIEWPORT_WIDTH = 128;
/** @const @type {number} */ glsShaderLibraryCase.VIEWPORT_HEIGHT = 128;
/**
* Shader compilation expected result enum
* @enum {number}
*/
glsShaderLibraryCase.expectResult = {
EXPECT_PASS: 0,
EXPECT_COMPILE_FAIL: 1,
EXPECT_LINK_FAIL: 2,
EXPECT_COMPILE_LINK_FAIL: 3,
EXPECT_VALIDATION_FAIL: 4,
EXPECT_BUILD_SUCCESSFUL: 5
};
/**
* Test case type
* @enum {number}
*/
glsShaderLibraryCase.caseType = {
CASETYPE_COMPLETE: 0, //!< Has all shaders specified separately.
CASETYPE_VERTEX_ONLY: 1, //!< "Both" case, vertex shader sub case.
CASETYPE_FRAGMENT_ONLY: 2 //!< "Both" case, fragment shader sub case.
};
/**
* glsShaderLibraryCase.BeforeDrawValidator target type enum
* @enum {number}
*/
glsShaderLibraryCase.targetType = {
PROGRAM: 0,
PIPELINE: 1
};
/**
* Shader case type enum
* @enum {number}
*/
glsShaderLibraryCase.shaderCase = {
STORAGE_INPUT: 0,
STORAGE_OUTPUT: 1,
STORAGE_UNIFORM: 2
};
/**
* Checks if shader uses in/out qualifiers depending on the version
* @param {string} version
* @return {boolean} version
*/
glsShaderLibraryCase.usesShaderInoutQualifiers = function(version) {
switch (version) {
case '100':
case '130':
case '140':
case '150':
return false;
default:
return true;
}
};
/**
* Checks if version supports fragment highp precision
* @param {string} version
* @return {boolean} version ,True when is different from version 100
*/
glsShaderLibraryCase.supportsFragmentHighp = function(version) {
return version !== '100';
};
/**
* This functions builds a matching vertex shader for a 'both' case, when
* the fragment shader is being tested.
* We need to build attributes and varyings for each 'input'.
* @param { {values:Array}} valueBlock
* @return {string} res
*/
glsShaderLibraryCase.genVertexShader = function(valueBlock) {
/** @type {string} */ var res = '';
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
/** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
/** @type {string} */ var vtxOut = usesInout ? 'out' : 'varying';
res += '#version ' + state.currentTest.spec.targetVersion + '\n';
res += 'precision highp float;\n';
res += 'precision highp int;\n';
res += '\n';
res += vtxIn + ' highp vec4 dEQP_Position;\n';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
var val = valueBlock.values[ndx];
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
/** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
res += vtxIn + ' ' + floatType + ' a_' + val.valueName + ';\n';
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
res += vtxOut + ' ' + floatType + ' ' + val.valueName + ';\n';
else
res += vtxOut + ' ' + floatType + ' v_' + val.valueName + ';\n';
}
}
res += '\n';
// Main function.
// - gl_Position = dEQP_Position;
// - for each input: write attribute directly to varying
res += 'void main()\n';
res += ' {\n';
res += '\tgl_Position = dEQP_Position;\n';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
var val = valueBlock.values[ndx];
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
/** @type {string} */ var name = val.valueName;
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
res += '\t' + name + ' = a_' + name + ';\n';
else
res += '\tv_' + name + ' = a_' + name + ';\n';
}
}
res += '}\n';
return res;
};
/**
* @param { {values:Array}} valueBlock
* @param {boolean} useFloatTypes
* @return {string} stream
*/
glsShaderLibraryCase.genCompareFunctions = function(valueBlock, useFloatTypes) {
var cmpTypeFound = {};
/** @type {string} */ var stream = '';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT)
cmpTypeFound[gluShaderUtil.getDataTypeName(val.dataType)] = true;
}
if (useFloatTypes) {
if (cmpTypeFound['bool']) stream += 'bool isOk (float a, bool b) { return ((a > 0.5) == b); }\n';
if (cmpTypeFound['bvec2']) stream += 'bool isOk (vec2 a, bvec2 b) { return (greaterThan(a, vec2(0.5)) == b); }\n';
if (cmpTypeFound['bvec3']) stream += 'bool isOk (vec3 a, bvec3 b) { return (greaterThan(a, vec3(0.5)) == b); }\n';
if (cmpTypeFound['bvec4']) stream += 'bool isOk (vec4 a, bvec4 b) { return (greaterThan(a, vec4(0.5)) == b); }\n';
if (cmpTypeFound['int']) stream += 'bool isOk (float a, int b) { float atemp = a+0.5; return (float(b) <= atemp && atemp <= float(b+1)); }\n';
if (cmpTypeFound['ivec2']) stream += 'bool isOk (vec2 a, ivec2 b) { return (ivec2(floor(a + 0.5)) == b); }\n';
if (cmpTypeFound['ivec3']) stream += 'bool isOk (vec3 a, ivec3 b) { return (ivec3(floor(a + 0.5)) == b); }\n';
if (cmpTypeFound['ivec4']) stream += 'bool isOk (vec4 a, ivec4 b) { return (ivec4(floor(a + 0.5)) == b); }\n';
if (cmpTypeFound['uint']) stream += 'bool isOk (float a, uint b) { float atemp = a+0.5; return (float(b) <= atemp && atemp <= float(b+1u)); }\n';
if (cmpTypeFound['uvec2']) stream += 'bool isOk (vec2 a, uvec2 b) { return (uvec2(floor(a + 0.5)) == b); }\n';
if (cmpTypeFound['uvec3']) stream += 'bool isOk (vec3 a, uvec3 b) { return (uvec3(floor(a + 0.5)) == b); }\n';
if (cmpTypeFound['uvec4']) stream += 'bool isOk (vec4 a, uvec4 b) { return (uvec4(floor(a + 0.5)) == b); }\n';
} else {
if (cmpTypeFound['bool']) stream += 'bool isOk (bool a, bool b) { return (a == b); }\n';
if (cmpTypeFound['bvec2']) stream += 'bool isOk (bvec2 a, bvec2 b) { return (a == b); }\n';
if (cmpTypeFound['bvec3']) stream += 'bool isOk (bvec3 a, bvec3 b) { return (a == b); }\n';
if (cmpTypeFound['bvec4']) stream += 'bool isOk (bvec4 a, bvec4 b) { return (a == b); }\n';
if (cmpTypeFound['int']) stream += 'bool isOk (int a, int b) { return (a == b); }\n';
if (cmpTypeFound['ivec2']) stream += 'bool isOk (ivec2 a, ivec2 b) { return (a == b); }\n';
if (cmpTypeFound['ivec3']) stream += 'bool isOk (ivec3 a, ivec3 b) { return (a == b); }\n';
if (cmpTypeFound['ivec4']) stream += 'bool isOk (ivec4 a, ivec4 b) { return (a == b); }\n';
if (cmpTypeFound['uint']) stream += 'bool isOk (uint a, uint b) { return (a == b); }\n';
if (cmpTypeFound['uvec2']) stream += 'bool isOk (uvec2 a, uvec2 b) { return (a == b); }\n';
if (cmpTypeFound['uvec3']) stream += 'bool isOk (uvec3 a, uvec3 b) { return (a == b); }\n';
if (cmpTypeFound['uvec4']) stream += 'bool isOk (uvec4 a, uvec4 b) { return (a == b); }\n';
}
if (cmpTypeFound['float'])
stream += 'bool isOk (float a, float b, float eps) { return (abs(a-b) <= (eps*abs(b) + eps)); }\n';
if (cmpTypeFound['vec2'])
stream += 'bool isOk (vec2 a, vec2 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n';
if (cmpTypeFound['vec3'])
stream += 'bool isOk (vec3 a, vec3 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n';
if (cmpTypeFound['vec4'])
stream += 'bool isOk (vec4 a, vec4 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n';
if (cmpTypeFound['mat2'])
stream += 'bool isOk (mat2 a, mat2 b, float eps) { vec2 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec2(eps))); }\n';
if (cmpTypeFound['mat2x3'])
stream += 'bool isOk (mat2x3 a, mat2x3 b, float eps) { vec3 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec3(eps))); }\n';
if (cmpTypeFound['mat2x4'])
stream += 'bool isOk (mat2x4 a, mat2x4 b, float eps) { vec4 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec4(eps))); }\n';
if (cmpTypeFound['mat3x2'])
stream += 'bool isOk (mat3x2 a, mat3x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec2(eps))); }\n';
if (cmpTypeFound['mat3'])
stream += 'bool isOk (mat3 a, mat3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec3(eps))); }\n';
if (cmpTypeFound['mat3x4'])
stream += 'bool isOk (mat3x4 a, mat3x4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec4(eps))); }\n';
if (cmpTypeFound['mat4x2'])
stream += 'bool isOk (mat4x2 a, mat4x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec2(eps))); }\n';
if (cmpTypeFound['mat4x3'])
stream += 'bool isOk (mat4x3 a, mat4x3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec3(eps))); }\n';
if (cmpTypeFound['mat4'])
stream += 'bool isOk (mat4 a, mat4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec4(eps))); }\n';
return stream;
};
/**
* @param {string} dstVec4Var
* @param { {values:Array}} valueBlock
* @param {string} nonFloatNamePrefix
* @param {?string=} checkVarName
* @return {string} output
*/
glsShaderLibraryCase.genCompareOp = function(dstVec4Var, valueBlock, nonFloatNamePrefix, checkVarName) {
/** @type {boolean} */ var isFirstOutput = true;
/** @type {string} */ var output = '';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
/** @type {string} */ var valueName = val.valueName;
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
// Check if we're only interested in one variable (then skip if not the right one).
if (checkVarName && (valueName !== checkVarName))
continue;
// Prefix.
if (isFirstOutput) {
output += 'bool RES = ';
isFirstOutput = false;
} else
output += 'RES = RES && ';
// Generate actual comparison.
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
output += 'isOk(' + valueName + ', ref_' + valueName + ', 0.05);\n';
else
output += 'isOk(' + nonFloatNamePrefix + valueName + ', ref_' + valueName + ');\n';
}
// \note Uniforms are already declared in shader.
}
if (isFirstOutput)
output += dstVec4Var + ' = vec4(1.0);\n'; // \todo [petri] Should we give warning if not expect-failure case?
else
output += dstVec4Var + ' = vec4(RES, RES, RES, 1.0);\n';
return output;
};
/**
* @param { {values:Array}} valueBlock
* @return {string} shader
*/
glsShaderLibraryCase.genFragmentShader = function(valueBlock) {
/** @type {string} */ var shader = '';
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
/** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
/** @type {string} */ var vtxOut = usesInout ? 'out' : 'varying';
/** @type {boolean} */ var customColorOut = usesInout;
/** @type {string} */ var fragIn = usesInout ? 'in' : 'varying';
/** @type {string} */ var prec = glsShaderLibraryCase.supportsFragmentHighp(state.currentTest.spec.targetVersion) ? 'highp' : 'mediump';
shader += '#version ' + state.currentTest.spec.targetVersion + '\n';
shader += 'precision ' + prec + ' float;\n';
shader += 'precision ' + prec + ' int;\n';
shader += '\n';
if (customColorOut) {
shader += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';
shader += '\n';
}
shader += glsShaderLibraryCase.genCompareFunctions(valueBlock, true);
shader += '\n';
// Declarations (varying, reference for each output).
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
/** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
/** @type {string} */ var refType = gluShaderUtil.getDataTypeName(val.dataType);
if (val.storageType == glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
shader += fragIn + ' ' + floatType + ' ' + val.valueName + ';\n';
else
shader += fragIn + ' ' + floatType + ' v_' + val.valueName + ';\n';
shader += 'uniform ' + refType + ' ref_' + val.valueName + ';\n';
}
}
shader += '\n';
shader += 'void main()\n';
shader += ' {\n';
shader += '\t';
shader += glsShaderLibraryCase.genCompareOp(customColorOut ? 'dEQP_FragColor' : 'gl_FragColor', valueBlock, 'v_', null);
shader += '}\n';
return shader;
};
glsShaderLibraryCase.caseRequirement = (function() {
/**
* @constructor
*/
var CaseRequirement = function() {
/**
* @param {number} shaderType
* @return {boolean}
*/
this.isAffected = function(shaderType) {
for (var i = 0; i < this.shaderTypes.length; i++)
if (this.shaderTypes[i] === shaderType)
return true;
return false;
};
this.checkRequirements = function(gl) {
if (this.type === requirementType.EXTENSION) {
var extns = gl.getSupportedExtensions();
for (var i = 0; i < extns.length; i++)
for (var j = 0; j < this.requirements.length; j++)
if (extns[i] === this.requirements[j]) {
this.supportedExtension = this.requirements[j];
return true;
}
if (this.requirements.length === 1)
throw Error('Test requires extension of ' + this.requirements[0]);
else
throw Error('Test requires any extension of ' + this.requirements);
} else if (this.type === requirementType.IMPLEMENTATION_LIMIT) {
var value = gl.getParameter(this.enumName);
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'Failed to read parameter ' + this.enumName, false, true);
if (!(value > this.referenceValue))
throw Error('Test requires ' + this.enumName + ' (' + value + ') > ' + this.referenceValue);
}
};
this.getSupportedExtension = function() {
return this.supportedExtension;
};
};
var createAnyExtensionRequirement = function(requirements, shaderTypes) {
var cr = new CaseRequirement();
cr.type = requirementType.EXTENSION;
cr.requirements = requirements;
cr.shaderTypes = shaderTypes;
return cr;
};
var createLimitRequirement = function(enumName, ref) {
var cr = new CaseRequirement();
cr.type = requirementType.IMPLEMENTATION_LIMIT;
cr.enumName = enumName;
cr.referenceValue = ref;
};
/**
* @enum {number}
*/
var requirementType = {
EXTENSION: 0,
IMPLEMENTATION_LIMIT: 1
};
return {
createAnyExtensionRequirement: createAnyExtensionRequirement,
createLimitRequirement: createLimitRequirement,
requirementType: requirementType
};
}());
/** Specialize a shader only for the vertex test case.
* @param {string} baseCode
* @param {number} shaderType
* @param {Array<Object>} requirements
* @return {string} resultBuf
*/
glsShaderLibraryCase.injectExtensionRequirements = function(baseCode, shaderType, requirements) {
/**
* @param {Array<Object>} requirements
* @param {number} shaderType
* @return {string} buf
*/
var generateExtensionStatements = function(requirements, shaderType) {
/** @type {string} */ var buf = '';
if (requirements)
for (var ndx = 0; ndx < requirements.length; ndx++)
if (requirements[ndx].type === glsShaderLibraryCase.caseRequirement.requirementType.EXTENSION &&
requirements[ndx].isAffected(shaderType))
buf += '#extension ' + requirements[ndx].getSupportedExtension() + ' : require\n';
return buf;
};
/** @type {string} */ var extensions = generateExtensionStatements(requirements, shaderType);
if (extensions.length === 0)
return baseCode;
/** @type {Array<string>} */ var splitLines = baseCode.split('\n');
/** @type {boolean} */ var firstNonPreprocessorLine = true;
/** @type {string} */ var resultBuf = '';
for (var i = 0; i < splitLines.length; i++) {
/** @const @type {boolean} */ var isPreprocessorDirective = (splitLines[i].match(/^\s*#/) !== null);
if (!isPreprocessorDirective && firstNonPreprocessorLine) {
firstNonPreprocessorLine = false;
resultBuf += extensions;
}
resultBuf += splitLines[i] + '\n';
}
return resultBuf;
};
/** Specialize a shader for the vertex shader test case.
* @param {string} src
* @param { {values:Array}} valueBlock
* @return {string} withExt
*/
glsShaderLibraryCase.specializeVertexShader = function(src, valueBlock) {
/** @type {string} */ var decl = '';
/** @type {string} */ var setup = '';
/** @type {string} */ var output = '';
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
/** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
/** @type {string} */ var vtxOut = usesInout ? 'out' : 'varying';
// Output (write out position).
output += 'gl_Position = dEQP_Position;\n';
// Declarations (position + attribute for each input, varying for each output).
decl += vtxIn + ' highp vec4 dEQP_Position;\n';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
/** @type {string} */ var valueName = val.valueName;
/** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
/** @type {string} */ var dataTypeName = gluShaderUtil.getDataTypeName(val.dataType);
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float') {
decl += vtxIn + ' ' + floatType + ' ' + valueName + ';\n';
} else {
decl += vtxIn + ' ' + floatType + ' a_' + valueName + ';\n';
setup += dataTypeName + ' ' + valueName + ' = ' + dataTypeName + '(a_' + valueName + ');\n';
}
} else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
decl += vtxOut + ' ' + floatType + ' ' + valueName + ';\n';
else {
decl += vtxOut + ' ' + floatType + ' v_' + valueName + ';\n';
decl += dataTypeName + ' ' + valueName + ';\n';
output += 'v_' + valueName + ' = ' + floatType + '(' + valueName + ');\n';
}
}
}
/** @type {string} */
var baseSrc = src
.replace(/\$\{DECLARATIONS\}/g, decl)
.replace(/\$\{DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
.replace(/\$\{SETUP\}/g, setup)
.replace(/\$\{OUTPUT\}/g, output)
.replace(/\$\{POSITION_FRAG_COLOR\}/g, 'gl_Position');
/** @type {string} */
var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.VERTEX, state.currentTest.spec.requirements);
return withExt;
};
/** Specialize a shader only for the vertex test case.
* @param {string} src
* @param { {values:Array}} valueBlock
* @return {string} withExt
*/
glsShaderLibraryCase.specializeVertexOnly = function(src, valueBlock) {
/** @type {string} */ var decl = '';
/** @type {string} */ var setup = '';
/** @type {string} */ var output = '';
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
/** @type {string} */ var vtxIn = usesInout ? 'in' : 'attribute';
// Output (write out position).
output += 'gl_Position = dEQP_Position;\n';
// Declarations (position + attribute for each input, varying for each output).
decl += vtxIn + ' highp vec4 dEQP_Position;\n';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
/** @type {string} */ var valueName = val.valueName;
/** @type {string} */ var type = gluShaderUtil.getDataTypeName(val.dataType);
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float') {
decl += vtxIn + ' ' + type + ' ' + valueName + ';\n';
} else {
/** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
decl += vtxIn + ' ' + floatType + ' a_' + valueName + ';\n';
setup += type + ' ' + valueName + ' = ' + type + '(a_' + valueName + ');\n';
}
} else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM &&
!val.valueName.match('\\.'))
decl += 'uniform ' + type + ' ' + valueName + ';\n';
}
/** @type {string} */
var baseSrc = src
.replace(/\$\{VERTEX_DECLARATIONS\}/g, decl)
.replace(/\$\{VERTEX_DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
.replace(/\$\{VERTEX_SETUP\}/g, setup)
.replace(/\$\{VERTEX_OUTPUT\}/g, output);
/** @type {string} */
var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.VERTEX, state.currentTest.spec.requirements);
return withExt;
};
/** Specialize a shader for the fragment shader test case.
* @param {string} src
* @param { {values:Array}} valueBlock
* @return {string} withExt
*/
glsShaderLibraryCase.specializeFragmentShader = function(src, valueBlock) {
/** @type {string} */ var decl = '';
/** @type {string} */ var setup = '';
/** @type {string} */ var output = '';
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
/** @type {boolean} */ var customColorOut = usesInout;
/** @type {string} */ var fragIn = usesInout ? 'in' : 'varying';
/** @type {string} */ var fragColor = customColorOut ? 'dEQP_FragColor' : 'gl_FragColor';
decl += glsShaderLibraryCase.genCompareFunctions(valueBlock, false);
output += glsShaderLibraryCase.genCompareOp(fragColor, valueBlock, '', null);
if (customColorOut)
decl += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
/** @type {string} */ var valueName = val.valueName;
/** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
/** @type {string} */ var refType = gluShaderUtil.getDataTypeName(val.dataType);
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
if (gluShaderUtil.getDataTypeScalarType(val.dataType) === 'float')
decl += fragIn + ' ' + floatType + ' ' + valueName + ';\n';
else {
decl += fragIn + ' ' + floatType + ' v_' + valueName + ';\n';
var offset = gluShaderUtil.isDataTypeIntOrIVec(val.dataType) ? ' * 1.0025' : ''; // \todo [petri] bit of a hack to avoid errors in chop() due to varying interpolation
setup += refType + ' ' + valueName + ' = ' + refType + '(v_' + valueName + offset + ');\n';
}
} else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
decl += 'uniform ' + refType + ' ref_' + valueName + ';\n';
decl += refType + ' ' + valueName + ';\n';
}
}
/* \todo [2010-04-01 petri] Check all outputs. */
/** @type {string} */
var baseSrc = src
.replace(/\$\{DECLARATIONS\}/g, decl)
.replace(/\$\{DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
.replace(/\$\{SETUP\}/g, setup)
.replace(/\$\{OUTPUT\}/g, output)
.replace(/\$\{POSITION_FRAG_COLOR\}/g, fragColor);
/** @type {string} */
var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.FRAGMENT, state.currentTest.spec.requirements);
return withExt;
};
/** Specialize a shader only for the fragment test case.
* @param {string} src
* @param { {values:Array}} valueBlock
* @return {string} withExt
*/
glsShaderLibraryCase.specializeFragmentOnly = function(src, valueBlock) {
/** @type {string} */ var decl = '';
/** @type {string} */ var output = '';
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {boolean} */ var usesInout = glsShaderLibraryCase.usesShaderInoutQualifiers(state.currentTest.spec.targetVersion);
/** @type {boolean} */ var customColorOut = usesInout;
/** @type {string} */ var fragIn = usesInout ? 'in' : 'varying';
/** @type {string} */ var fragColor = customColorOut ? 'dEQP_FragColor' : 'gl_FragColor';
decl += glsShaderLibraryCase.genCompareFunctions(valueBlock, false);
output += glsShaderLibraryCase.genCompareOp(fragColor, valueBlock, '', null);
if (customColorOut)
decl += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';
for (var ndx = 0; ndx < valueBlock.values.length; ndx++) {
/** @type {Array} */ var val = valueBlock.values[ndx];
/** @type {string} */ var valueName = val.valueName;
/** @type {string} */ var floatType = gluShaderUtil.getDataTypeFloatScalars(val.dataType);
/** @type {string} */ var refType = gluShaderUtil.getDataTypeName(val.dataType);
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
decl += 'uniform ' + refType + ' ref_' + valueName + ';\n';
decl += refType + ' ' + valueName + ';\n';
} else if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM &&
!valueName.match('\\.'))
decl += 'uniform ' + refType + ' ' + valueName + ';\n';
}
/** @type {string} */
var baseSrc = src
.replace(/\$\{FRAGMENT_DECLARATIONS\}/g, decl)
.replace(/\$\{FRAGMENT_DECLARATIONS:single-line\}/g, decl.replace(/\n/g, ' '))
.replace(/\$\{FRAGMENT_OUTPUT\}/g, output)
.replace(/\$\{FRAG_COLOR\}/g, fragColor);
/** @type {string} */
var withExt = glsShaderLibraryCase.injectExtensionRequirements(baseSrc, gluShaderProgram.shaderType.FRAGMENT, state.currentTest.spec.requirements);
return withExt;
};
/**
* Is tessellation present
* @return {boolean} True if tessellation is present
*/
glsShaderLibraryCase.isTessellationPresent = function() {
/* TODO: GLES 3.1: implement */
return false;
};
glsShaderLibraryCase.setUniformValue = function(gl, pipelinePrograms, name, val, arrayNdx) {
/** @type {boolean} */ var foundAnyMatch = false;
for (var programNdx = 0; programNdx < pipelinePrograms.length; ++programNdx) {
/** @const @type {WebGLUniformLocation} */ var loc = gl.getUniformLocation(pipelinePrograms[programNdx], name);
/** @const @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(val.dataType);
/** @const @type {number} */ var elemNdx = (val.arrayLength === 1) ? (0) : (arrayNdx * scalarSize);
if (!loc)
continue;
foundAnyMatch = true;
gl.useProgram(pipelinePrograms[programNdx]);
/** @type {Array} */ var element = val.elements.slice(elemNdx, elemNdx + scalarSize);
switch (val.dataType) {
case gluShaderUtil.DataType.FLOAT: gl.uniform1fv(loc, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_VEC2: gl.uniform2fv(loc, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_VEC3: gl.uniform3fv(loc, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_VEC4: gl.uniform4fv(loc, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT2: gl.uniformMatrix2fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT3: gl.uniformMatrix3fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT4: gl.uniformMatrix4fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.INT: gl.uniform1iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.INT_VEC2: gl.uniform2iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.INT_VEC3: gl.uniform3iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.INT_VEC4: gl.uniform4iv(loc, new Int32Array(element)); break;
/** TODO: What type should be used for bool uniforms? */
case gluShaderUtil.DataType.BOOL: gl.uniform1iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.BOOL_VEC2: gl.uniform2iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.BOOL_VEC3: gl.uniform3iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.BOOL_VEC4: gl.uniform4iv(loc, new Int32Array(element)); break;
case gluShaderUtil.DataType.UINT: gl.uniform1uiv(loc, new Uint32Array(element)); break;
case gluShaderUtil.DataType.UINT_VEC2: gl.uniform2uiv(loc, new Uint32Array(element)); break;
case gluShaderUtil.DataType.UINT_VEC3: gl.uniform3uiv(loc, new Uint32Array(element)); break;
case gluShaderUtil.DataType.UINT_VEC4: gl.uniform4uiv(loc, new Uint32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT2X3: gl.uniformMatrix2x3fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT2X4: gl.uniformMatrix2x4fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT3X2: gl.uniformMatrix3x2fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT3X4: gl.uniformMatrix3x4fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT4X2: gl.uniformMatrix4x2fv(loc, false, new Float32Array(element)); break;
case gluShaderUtil.DataType.FLOAT_MAT4X3: gl.uniformMatrix4x3fv(loc, false, new Float32Array(element)); break;
default:
testFailed('Unknown data type ' + val.dataType);
}
}
if (!foundAnyMatch)
bufferedLogToConsole('WARNING // Uniform \"' + name + '\" location is not valid, location = -1. Cannot set value to the uniform.');
};
/**
* Evaluates pixels, if they are white, black or there is any unexpected result
* @param {gluDrawUtil.Surface} surface
* @param {number} minX
* @param {number} maxX
* @param {number} minY
* @param {number} maxY
* @return {boolean} True if tessellation is present
*/
glsShaderLibraryCase.checkPixels = function(surface, minX, maxX, minY, maxY) {
/** @type {boolean} */ var allWhite = true;
/** @type {boolean} */ var allBlack = true;
/** @type {boolean} */ var anyUnexpected = false;
assertMsgOptions((maxX > minX) && (maxY > minY), 'glsShaderLibraryCase.checkPixels sanity check', false, true);
for (var y = minY; y <= maxY; y++) {
for (var x = minX; x <= maxX; x++) {
/** @type {number} */ var pixel = surface.getPixelUintRGB8(x, y);
/** @type {boolean} */ var isWhite = (pixel == 0xFFFFFF);
/** @type {boolean} */ var isBlack = (pixel == 0x000000);
allWhite = allWhite && isWhite;
allBlack = allBlack && isBlack;
anyUnexpected = anyUnexpected || (!isWhite && !isBlack);
// Early terminate as soon as we know the check hasn't passed
if (!allWhite && !allBlack)
break;
}
}
if (!allWhite) {
if (anyUnexpected)
testFailed('WARNING: expecting all rendered pixels to be white or black, but got other colors as well!');
else if (!allBlack)
testFailed('WARNING: got inconsistent results over the image, when all pixels should be the same color!');
return false;
}
return true;
};
/**
* Initialize a test case
*/
glsShaderLibraryCase.init = function() {
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {Object} */ var test = state.currentTest;
bufferedLogToConsole('Processing ' + test.fullName());
if (!test.spec.valueBlockList.length)
test.spec.valueBlockList.push(glsShaderLibraryCase.genValueBlock());
/** @type { {values:Array}} */ var valueBlock = test.spec.valueBlockList[0];
if (test.spec.requirements)
for (var ndx = 0; ndx < test.spec.requirements.length; ++ndx)
test.spec.requirements[ndx].checkRequirements();
/** @type {Array<gluShaderProgram.ShaderInfo>} */ var sources = [];
if (test.spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_COMPLETE) {
/** @type {string} */ var vertex = glsShaderLibraryCase.specializeVertexOnly(test.spec.vertexSource, valueBlock);
/** @type {string} */ var fragment = glsShaderLibraryCase.specializeFragmentOnly(test.spec.fragmentSource, valueBlock);
sources.push(gluShaderProgram.genVertexSource(vertex));
sources.push(gluShaderProgram.genFragmentSource(fragment));
} else if (test.spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_VERTEX_ONLY) {
sources.push(gluShaderProgram.genVertexSource(glsShaderLibraryCase.specializeVertexShader(test.spec.vertexSource, valueBlock)));
sources.push(gluShaderProgram.genFragmentSource(glsShaderLibraryCase.genFragmentShader(valueBlock)));
} else if (test.spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_FRAGMENT_ONLY) {
sources.push(gluShaderProgram.genVertexSource(glsShaderLibraryCase.genVertexShader(valueBlock)));
sources.push(gluShaderProgram.genFragmentSource(glsShaderLibraryCase.specializeFragmentShader(test.spec.fragmentSource, valueBlock)));
}
test.programs = [];
test.programs.push({
programSources: {
sources: sources
}
}
);
};
/**
* Execute a test case
* @return {boolean} True if test case passed
*/
glsShaderLibraryCase.execute = function() {
/** @const @type {number} */ var quadSize = 1.0;
/** @const @type {Array<number>} */
var s_positions = [
-quadSize, -quadSize, 0.0, 1.0,
-quadSize, +quadSize, 0.0, 1.0,
+quadSize, -quadSize, 0.0, 1.0,
+quadSize, +quadSize, 0.0, 1.0
];
/** @const @type {Array<number>} */
var s_indices = [
0, 1, 2,
1, 3, 2
];
var wtu = WebGLTestUtils;
/** @type {WebGL2RenderingContext} */ var gl = wtu.create3DContext('canvas');
/** @type {Object} */ var state = tcuTestCase.runner;
/** @type {Object} */ var test = state.currentTest;
/** @type {Object} */ var spec = test.spec;
// Compute viewport.
/* TODO: original code used random number generator to compute viewport, we use whole canvas */
/** @const @type {number} */ var width = Math.min(canvas.width, glsShaderLibraryCase.VIEWPORT_WIDTH);
/** @const @type {number} */ var height = Math.min(canvas.height, glsShaderLibraryCase.VIEWPORT_HEIGHT);
/** @const @type {number} */ var viewportX = 0;
/** @const @type {number} */ var viewportY = 0;
/** @const @type {number} */ var numVerticesPerDraw = 4;
/** @const @type {boolean} */ var tessellationPresent = glsShaderLibraryCase.isTessellationPresent();
/** @type {boolean} */ var allCompilesOk = true;
/** @type {boolean} */ var allLinksOk = true;
/** @type {?string} */ var failReason = null;
/** @type {number} */ var vertexProgramID = -1;
/** @type {Array<WebGLProgram>} */ var pipelineProgramIDs = [];
/** @type {Array<gluShaderProgram.ShaderProgram>} */ var programs = [];
var programPipeline;
// Set the name of the current test so testFailedOptions/testPassedOptions can use it.
setCurrentTestName(test.fullName());
debug('Start testcase: ' + test.fullName());
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'Start testcase: ' + test.fullName(), false, true);
/** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, test.programs[0].programSources);
vertexProgramID = program.getProgram();
pipelineProgramIDs.push(program.getProgram());
programs.push(program);
// Check that compile/link results are what we expect.
for (var i = 0; i < program.shaders.length; i++) {
if (!program.shaders[i].info.compileOk)
allCompilesOk = false;
}
if (!program.getProgramInfo().linkOk)
allLinksOk = false;
switch (spec.expectResult) {
case glsShaderLibraryCase.expectResult.EXPECT_PASS:
case glsShaderLibraryCase.expectResult.EXPECT_VALIDATION_FAIL:
case glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL:
if (!allCompilesOk)
failReason = 'expected shaders to compile and link properly, but failed to compile.';
else if (!allLinksOk)
failReason = 'expected shaders to compile and link properly, but failed to link.';
break;
case glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL:
if (allCompilesOk && !allLinksOk)
failReason = 'expected compilation to fail, but shaders compiled and link failed.';
else if (allCompilesOk)
failReason = 'expected compilation to fail, but shaders compiled correctly.';
break;
case glsShaderLibraryCase.expectResult.EXPECT_LINK_FAIL:
if (!allCompilesOk)
failReason = 'expected linking to fail, but unable to compile.';
else if (allLinksOk)
failReason = 'expected linking to fail, but passed.';
break;
case glsShaderLibraryCase.expectResult.EXPECT_COMPILE_LINK_FAIL:
if (allCompilesOk && allLinksOk)
failReason = 'expected compile or link to fail, but passed.';
break;
default:
testFailedOptions('Unknown expected result', true);
return false;
}
if (failReason != null) {
// \todo [2010-06-07 petri] These should be handled in the test case?
// If implementation parses shader at link time, report it as quality warning.
if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL && allCompilesOk && !allLinksOk)
bufferedLogToConsole('Quality warning: implementation parses shader at link time: ' + failReason);
else {
bufferedLogToConsole('ERROR: ' + failReason);
testFailedOptions(failReason, true);
}
return false;
}
// Return if compile/link expected to fail.
if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL ||
spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_COMPILE_LINK_FAIL ||
spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_LINK_FAIL ||
spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL) {
if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL) {
testPassedOptions('Compile/link is expected to succeed', true);
} else {
testPassedOptions('Compile/link is expected to fail', true);
}
setCurrentTestName('');
return (failReason === null);
}
// Setup viewport.
gl.viewport(viewportX, viewportY, width, height);
// Start using program
gl.useProgram(vertexProgramID);
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'glUseProgram()', false, true);
// Fetch location for positions positions.
/** @type {number} */ var positionLoc = gl.getAttribLocation(vertexProgramID, 'dEQP_Position');
if (positionLoc === -1) {
testFailedOptions("no location found for attribute 'dEQP_Position'", true);
return false;
}
// Iterate all value blocks.
for (var blockNdx = 0; blockNdx < spec.valueBlockList.length; blockNdx++) {
/** @type { {values:Array}} */ var block = spec.valueBlockList[blockNdx];
// always render at least one pass even if there is no input/output data
/** @const @type {number} */ var numRenderPasses = Math.max(block.arrayLength, 1);
// Iterate all array sub-cases.
for (var arrayNdx = 0; arrayNdx < numRenderPasses; arrayNdx++) {
/** @const @type {number} */ var numValues = block.values.length;
/** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [];
/** @type {number} */ var attribValueNdx = 0;
/** @type {number} */ var postDrawError;
vertexArrays.push(new gluDrawUtil.VertexArrayBinding(gl.FLOAT, positionLoc, 4, numVerticesPerDraw, s_positions));
// Collect VA pointer for inputs
for (var valNdx = 0; valNdx < numValues; valNdx++) {
var val = block.values[valNdx];
/** @const @type {string} */ var valueName = val.valueName;
/** @const @type {gluShaderUtil.DataType} */ var dataType = val.dataType;
/** @const @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(val.dataType);
if (val.storageType === glsShaderLibraryCase.shaderCase.STORAGE_INPUT) {
// Replicate values four times.
/** @type {Array} */ var scalars = [];
for (var repNdx = 0; repNdx < numVerticesPerDraw; repNdx++)
for (var ndx = 0; ndx < scalarSize; ndx++)
scalars[repNdx * scalarSize + ndx] = val.elements[arrayNdx * scalarSize + ndx];
// Attribute name prefix.
/** @type {string} */ var attribPrefix = '';
// \todo [2010-05-27 petri] Should latter condition only apply for vertex cases (or actually non-fragment cases)?
if ((spec.caseType === glsShaderLibraryCase.caseType.CASETYPE_FRAGMENT_ONLY) || (gluShaderUtil.getDataTypeScalarType(dataType) !== 'float'))
attribPrefix = 'a_';
// Input always given as attribute.
/** @type {string} */ var attribName = attribPrefix + valueName;
/** @type {number} */ var attribLoc = gl.getAttribLocation(vertexProgramID, attribName);
if (attribLoc === -1) {
bufferedLogToConsole("Warning: no location found for attribute '" + attribName + "'");
continue;
}
if (gluShaderUtil.isDataTypeMatrix(dataType)) {
var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(dataType);
var numRows = gluShaderUtil.getDataTypeMatrixNumRows(dataType);
assertMsgOptions(scalarSize === numCols * numRows, 'Matrix size sanity check', false, true);
for (var i = 0; i < numCols; i++)
vertexArrays.push(new gluDrawUtil.VertexArrayBinding(gl.FLOAT, attribLoc + i, numRows, numVerticesPerDraw, scalars, scalarSize * 4, i * numRows * 4));
} else
vertexArrays.push(new gluDrawUtil.VertexArrayBinding(gl.FLOAT, attribLoc, scalarSize, numVerticesPerDraw, scalars));
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set vertex attrib array', false, true);
}
}
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'before set uniforms', false, true);
// set uniform values for outputs (refs).
for (var valNdx = 0; valNdx < numValues; valNdx++) {
/** @type {Array} */ var val1 = block.values[valNdx];
/** @type {string} */ var valueName1 = val1.valueName;
if (val1.storageType === glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT) {
// Set reference value.
glsShaderLibraryCase.setUniformValue(gl, pipelineProgramIDs, 'ref_' + valueName1, val1, arrayNdx);
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set reference uniforms', false, true);
} else if (val1.storageType === glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM) {
glsShaderLibraryCase.setUniformValue(gl, pipelineProgramIDs, valueName1, val1, arrayNdx);
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set uniforms', false, true);
}
}
// Clear.
gl.clearColor(0.125, 0.25, 0.5, 1);
gl.clear(gl.COLOR_BUFFER_BIT);
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'clear buffer', false, true);
// Use program or pipeline
if (spec.separatePrograms)
gl.useProgram(null);
else
gl.useProgram(vertexProgramID);
// Draw.
// if (tessellationPresent) {
// gl.patchParameteri(gl.PATCH_VERTICES, 3);
// assertMsgOptions(gl.getError() === gl.NO_ERROR, 'set patchParameteri(PATCH_VERTICES, 3)', false, true);
// }
gluDrawUtil.draw(gl, vertexProgramID, vertexArrays, gluDrawUtil.triangles(s_indices));
postDrawError = gl.getError();
if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_PASS) {
/** @type {gluDrawUtil.Surface} */ var surface = new gluDrawUtil.Surface();
/** @const @type {number} */ var w = s_positions[3];
/** @const @type {number} */ var minY = Math.ceil(((-quadSize / w) * 0.5 + 0.5) * height + 1.0);
/** @const @type {number} */ var maxY = Math.floor(((+quadSize / w) * 0.5 + 0.5) * height - 0.5);
/** @const @type {number} */ var minX = Math.ceil(((-quadSize / w) * 0.5 + 0.5) * width + 1.0);
/** @const @type {number} */ var maxX = Math.floor(((+quadSize / w) * 0.5 + 0.5) * width - 0.5);
assertMsgOptions(postDrawError === gl.NO_ERROR, 'draw', false, true);
surface.readSurface(gl, viewportX, viewportY, width, height);
assertMsgOptions(gl.getError() === gl.NO_ERROR, 'read pixels', false, true);
if (!glsShaderLibraryCase.checkPixels(surface, minX, maxX, minY, maxY)) {
testFailedOptions((
'INCORRECT RESULT for (value block ' + (blockNdx + 1) +
' of ' + spec.valueBlockList.length + ', sub-case ' +
(arrayNdx + 1) + ' of ' + block.arrayLength + '):'
), true);
/* TODO: Port */
/*
log << TestLog::Message << "Failing shader input/output values:" << TestLog::EndMessage;
dumpValues(block, arrayNdx);
// Dump image on failure.
log << TestLog::Image("Result", "Rendered result image", surface);
*/
gl.useProgram(null);
return false;
}
} else if (spec.expectResult === glsShaderLibraryCase.expectResult.EXPECT_VALIDATION_FAIL) {
/** TODO: GLES 3.1: Implement */
testFailedOptions('Unsupported test case', true);
}
}
}
gl.useProgram(null);
assertMsgOptions(gl.getError() === gl.NO_ERROR, '', true, true);
setCurrentTestName('');
return true;
};
glsShaderLibraryCase.runTestCases = function() {
/** @type {Object} */ var state = tcuTestCase.runner;
if (state.next()) {
try {
glsShaderLibraryCase.init();
glsShaderLibraryCase.execute();
} catch (err) {
bufferedLogToConsole(err);
}
tcuTestCase.runner.runCallback(glsShaderLibraryCase.runTestCases);
} else
tcuTestCase.runner.terminate();
};
glsShaderLibraryCase.genValueBlock = function() {
return {
/** @type {Array} */ values: [],
/** @type {number} */ arrayLength: 0
};
};
});