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.es3fShaderBuiltinVarTests');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuLogImage');
goog.require('framework.common.tcuPixelFormat');
goog.require('framework.common.tcuRGBA');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.common.tcuTexture');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluVarType');
goog.require('framework.opengl.simplereference.sglrReferenceContext');
goog.require('framework.opengl.simplereference.sglrShaderProgram');
goog.require('framework.referencerenderer.rrFragmentOperations');
goog.require('framework.referencerenderer.rrGenericVector');
goog.require('framework.referencerenderer.rrMultisamplePixelBufferAccess');
goog.require('framework.referencerenderer.rrRenderer');
goog.require('framework.referencerenderer.rrRenderState');
goog.require('framework.referencerenderer.rrShadingContext');
goog.require('framework.referencerenderer.rrVertexAttrib');
goog.require('framework.referencerenderer.rrVertexPacket');
goog.require('modules.shared.glsShaderRenderCase');
goog.require('modules.shared.glsShaderExecUtil');
goog.scope(function() {
var es3fShaderBuiltinVarTests = functional.gles3.es3fShaderBuiltinVarTests;
var deMath = framework.delibs.debase.deMath;
var deString = framework.delibs.debase.deString;
var deRandom = framework.delibs.debase.deRandom;
var glsShaderExecUtil = modules.shared.glsShaderExecUtil;
var glsShaderRenderCase = modules.shared.glsShaderRenderCase;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluDrawUtil = framework.opengl.gluDrawUtil;
var gluVarType = framework.opengl.gluVarType;
var tcuPixelFormat = framework.common.tcuPixelFormat;
var tcuSurface = framework.common.tcuSurface;
var tcuTexture = framework.common.tcuTexture;
var tcuLogImage = framework.common.tcuLogImage;
var tcuTestCase = framework.common.tcuTestCase;
var tcuImageCompare = framework.common.tcuImageCompare;
var tcuRGBA = framework.common.tcuRGBA;
var rrGenericVector = framework.referencerenderer.rrGenericVector;
var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations;
var rrMultisamplePixelBufferAccess = framework.referencerenderer.rrMultisamplePixelBufferAccess;
var rrRenderer = framework.referencerenderer.rrRenderer;
var rrRenderState = framework.referencerenderer.rrRenderState;
var rrShadingContext = framework.referencerenderer.rrShadingContext;
var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib;
var rrVertexPacket = framework.referencerenderer.rrVertexPacket;
var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram;
var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext;
/** @typedef {function():number} */ es3fShaderBuiltinVarTests.GetConstantValueFunc;
/**
* @param {number} pname
* @return {number} getParameter returns values of any kind
*/
es3fShaderBuiltinVarTests.getInteger = function(pname) {
return /** @type {number} */ (gl.getParameter(pname));
};
/**
* @param {number} pname
* @return {number} forcing number
*/
es3fShaderBuiltinVarTests.getVectorsFromComps = function(pname) {
var value = /** @type {number} */ (gl.getParameter(pname));
assertMsgOptions(value%4 === 0, 'Expected value to be divisible by 4.', false, true);
return value / 4;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} desc
* @param {string} varName
* @param {es3fShaderBuiltinVarTests.GetConstantValueFunc} getValue
* @param {gluShaderProgram.shaderType} shaderType
*/
es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase = function(name, desc, varName, getValue, shaderType) {
tcuTestCase.DeqpTest.call(this, name, desc);
/** @type {string} */ this.m_varName = varName;
/** @type {es3fShaderBuiltinVarTests.GetConstantValueFunc} */ this.m_getValue = getValue;
/** @type {gluShaderProgram.shaderType} */ this.m_shaderType = shaderType;
};
es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.constructor = es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase;
es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.deinit = function() {
// an attempt to cleanup the GL state when the test fails
bufferedLogToConsole('ShaderBuildInConstantCase.deinit()');
gl.useProgram(null);
gl.bindBuffer(gl.ARRAY_BUFFER, null);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
};
/**
* @param {gluShaderProgram.shaderType} shaderType
* @param {string} varName
* @return {glsShaderExecUtil.ShaderExecutor}
*/
es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.createGetConstantExecutor = function(shaderType, varName) {
/** @type {glsShaderExecUtil.ShaderSpec} */ var shaderSpec = new glsShaderExecUtil.ShaderSpec();
shaderSpec.version = gluShaderUtil.GLSLVersion.V300_ES;
shaderSpec.source = 'result = ' + varName + ';\n';
shaderSpec.outputs.push(new glsShaderExecUtil.Symbol('result',
gluVarType.newTypeBasic(gluShaderUtil.DataType.INT, gluShaderUtil.precision.PRECISION_HIGHP)));
return glsShaderExecUtil.createExecutor(shaderType, shaderSpec);
};
/**
* @return {tcuTestCase.IterateResult}
*/
es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.iterate = function() {
/** @type {glsShaderExecUtil.ShaderExecutor} */
var shaderExecutor = this.createGetConstantExecutor(this.m_shaderType, this.m_varName);
/** @type {number} */ var reference = this.m_getValue();
/** @type {goog.NumberArray} */ var shaderExecutorResult;
/** @type {number} */ var result;
if (!shaderExecutor.isOk())
assertMsgOptions(false, 'Compile failed', false, true);
shaderExecutor.useProgram();
shaderExecutorResult = shaderExecutor.execute(1, null);
result = new Int32Array(shaderExecutorResult[0].buffer)[0];
bufferedLogToConsole(this.m_varName + ' = ' + result);
if (result != reference) {
bufferedLogToConsole('ERROR: Expected ' + this.m_varName + ' = ' + reference + '\n' +
'Test shader:' + shaderExecutor.m_program.getProgramInfo().infoLog);
testFailedOptions('Invalid builtin constant value', false);
} else
testPassedOptions('Pass', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @struct
* @constructor
* @param {number=} near
* @param {number=} far
*/
es3fShaderBuiltinVarTests.DepthRangeParams = function(near, far) {
/** @type {number} */ this.zNear = near === undefined ? 0.0 : near;
/** @type {number} */ this.zFar = far === undefined ? 1.0 : far;
};
/**
* @constructor
* @extends {glsShaderRenderCase.ShaderEvaluator}
* @param {es3fShaderBuiltinVarTests.DepthRangeParams} params
*/
es3fShaderBuiltinVarTests.DepthRangeEvaluator = function(params) {
/** @type {es3fShaderBuiltinVarTests.DepthRangeParams} */ this.m_params = params;
};
es3fShaderBuiltinVarTests.DepthRangeEvaluator.prototype = Object.create(glsShaderRenderCase.ShaderEvaluator.prototype);
es3fShaderBuiltinVarTests.DepthRangeEvaluator.prototype.constructor = es3fShaderBuiltinVarTests.DepthRangeEvaluator;
/**
* @param {glsShaderRenderCase.ShaderEvalContext} c
*/
es3fShaderBuiltinVarTests.DepthRangeEvaluator.prototype.evaluate = function(c) {
/** @type {number} */ var zNear = deMath.clamp(this.m_params.zNear, 0.0, 1.0);
/** @type {number} */ var zFar = deMath.clamp(this.m_params.zFar, 0.0, 1.0);
/** @type {number} */ var diff = zFar - zNear;
c.color[0] = zNear;
c.color[1] = zFar;
c.color[2] = diff * 0.5 + 0.5;
};
/**
* @constructor
* @extends {glsShaderRenderCase.ShaderRenderCase}
* @param {string} name
* @param {string} desc
* @param {boolean} isVertexCase
*/
es3fShaderBuiltinVarTests.ShaderDepthRangeTest = function(name, desc, isVertexCase) {
glsShaderRenderCase.ShaderRenderCase.call(this, name, desc, isVertexCase);
/** @type {es3fShaderBuiltinVarTests.DepthRangeParams} */ this.m_depthRange = new es3fShaderBuiltinVarTests.DepthRangeParams();
/** @type {es3fShaderBuiltinVarTests.DepthRangeEvaluator} */ this.m_evaluator = new es3fShaderBuiltinVarTests.DepthRangeEvaluator(this.m_depthRange);
/** @type {number} */ this.m_iterNdx = 0;
};
es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype);
es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype.constructor = es3fShaderBuiltinVarTests.ShaderDepthRangeTest;
es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype.init = function() {
/** @type {string} */ var defaultVertSrc = '' +
'#version 300 es\n' +
'in highp vec4 a_position;\n' +
'void main (void)\n' +
'{\n' +
' gl_Position = a_position;\n' +
'}\n';
/** @type {string} */ var defaultFragSrc = '' +
'#version 300 es\n' +
'in mediump vec4 v_color;\n' +
'layout(location = 0) out mediump vec4 o_color;\n\n' +
'void main (void)\n' +
'{\n' +
' o_color = v_color;\n' +
'}\n';
// Construct shader.
/** @type {string} */ var src = '#version 300 es\n';
if (this.m_isVertexCase)
src += 'in highp vec4 a_position;\n' +
'out mediump vec4 v_color;\n';
else
src += 'layout(location = 0) out mediump vec4 o_color;\n';
src += 'void main (void)\n{\n' +
'\t' + (this.m_isVertexCase ? 'v_color' : 'o_color') + ' = vec4(gl_DepthRange.near, gl_DepthRange.far, gl_DepthRange.diff*0.5 + 0.5, 1.0);\n';
if (this.m_isVertexCase)
src += '\tgl_Position = a_position;\n';
src += '}\n';
this.m_vertShaderSource = this.m_isVertexCase ? src : defaultVertSrc;
this.m_fragShaderSource = this.m_isVertexCase ? defaultFragSrc : src;
this.postinit();
};
/**
* @return {tcuTestCase.IterateResult}
*/
es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype.iterate = function() {
/** @type {Array<es3fShaderBuiltinVarTests.DepthRangeParams>} */ var cases = [
new es3fShaderBuiltinVarTests.DepthRangeParams(0.0, 1.0)
];
this.m_depthRange = cases[this.m_iterNdx];
bufferedLogToConsole('gl.depthRange(' + this.m_depthRange.zNear + ', ' + this.m_depthRange.zFar + ')');
gl.depthRange(this.m_depthRange.zNear, this.m_depthRange.zFar);
this.postiterate();
this.m_iterNdx += 1;
if (this.m_iterNdx == cases.length)
return tcuTestCase.IterateResult.STOP;
else
return tcuTestCase.IterateResult.CONTINUE;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderBuiltinVarTests.FragCoordXYZCase = function() {
tcuTestCase.DeqpTest.call(this, 'fragcoord_xyz', 'gl_FragCoord.xyz Test');
};
es3fShaderBuiltinVarTests.FragCoordXYZCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.FragCoordXYZCase.prototype.constructor = es3fShaderBuiltinVarTests.FragCoordXYZCase;
es3fShaderBuiltinVarTests.FragCoordXYZCase.prototype.iterate = function() {
/** @type {number} */ var width = gl.drawingBufferWidth;
/** @type {number} */ var height = gl.drawingBufferHeight;
/** @type {Array<number>} */ var threshold = deMath.add([1, 1, 1, 1], tcuPixelFormat.PixelFormatFromContext(gl).getColorThreshold());
/** @type {Array<number>} */ var scale = [1. / width, 1. / height, 1.0];
/** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height);
/** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height);
/** @type {string} */ var vtxSource = '' +
'#version 300 es\n' +
'in highp vec4 a_position;\n' +
'void main (void)\n' +
'{\n' +
' gl_Position = a_position;\n' +
'}\n';
/** @type {string} */ var fragSource = '' +
'#version 300 es\n' +
'uniform highp vec3 u_scale;\n' +
'layout(location = 0) out mediump vec4 o_color;\n' +
'void main (void)\n' +
'{\n' +
' o_color = vec4(gl_FragCoord.xyz*u_scale, 1.0);\n' +
'}\n';
/** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource));
bufferedLogToConsole(program.getProgramInfo().infoLog);
if (!program.isOk())
throw new Error('Compile failed');
// Draw with GL.
/** @type {Array<number>} */ var positions = [
-1.0, 1.0, -1.0, 1.0,
-1.0, -1.0, 0.0, 1.0,
1.0, 1.0, 0.0, 1.0,
1.0, -1.0, 1.0, 1.0
];
/** @type {Array<number>} */ var indices = [0, 1, 2, 2, 1, 3];
/** @type {WebGLUniformLocation} */ var scaleLoc = gl.getUniformLocation(program.getProgram(), 'u_scale');
/** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, positions);
gl.useProgram(program.getProgram());
gl.uniform3fv(scaleLoc, scale);
gl.viewport(0, 0, width, height);
gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indices));
testImg.readViewport(gl, [0, 0, width, height]);
// Draw reference
for (var y = 0; y < refImg.getHeight(); y++) {
for (var x = 0; x < refImg.getWidth(); x++) {
/** @type {number} */ var xf = (x + .5) / refImg.getWidth();
/** @type {number} */ var yf = (refImg.getHeight() - y - 1 + .5) / refImg.getHeight();
/** @type {number} */ var z = (xf + yf) / 2.0;
/** @type {Array<number>} */ var fragCoord = [x + .5, y + .5, z];
/** @type {Array<number>} */ var scaledFC = deMath.multiply(fragCoord, scale);
/** @type {Array<number>} */
var color = [
deMath.clamp(Math.floor(scaledFC[0] * 255 + 0.5), 0, 255),
deMath.clamp(Math.floor(scaledFC[1] * 255 + 0.5), 0, 255),
deMath.clamp(Math.floor(scaledFC[2] * 255 + 0.5), 0, 255),
255];
refImg.setPixel(x, y, color);
}
}
// Compare
/** @type {boolean} */ var isOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', refImg, testImg, threshold);
if (!isOk)
testFailedOptions('Image comparison failed', false);
else
testPassedOptions('Pass', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @param {Array<number>} s
* @param {Array<number>} w
* @param {number} nx
* @param {number} ny
* @return {number}
*/
es3fShaderBuiltinVarTests.projectedTriInterpolate = function(s, w, nx, ny) {
return (s[0] * (1.0 - nx - ny)/w[0] + s[1] * ny / w[1] + s[2] * nx / w[2]) / ((1.0 - nx - ny) / w[0] + ny / w[1] + nx / w[2]);
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderBuiltinVarTests.FragCoordWCase = function() {
tcuTestCase.DeqpTest.call(this, 'fragcoord_w', 'gl_FragCoord.w Test');
};
es3fShaderBuiltinVarTests.FragCoordWCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.FragCoordWCase.prototype.constructor = es3fShaderBuiltinVarTests.FragCoordWCase;
/**
* @return {tcuTestCase.IterateResult}
*/
es3fShaderBuiltinVarTests.FragCoordWCase.prototype.iterate = function() {
/** @type {number} */ var width = gl.drawingBufferWidth;
/** @type {number} */ var height = gl.drawingBufferHeight;
/** @type {Array<number>} */ var threshold = deMath.add([1, 1, 1, 1], tcuPixelFormat.PixelFormatFromContext(gl).getColorThreshold());
/** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height);
/** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height);
/** @type {Array<number>} */ var w = [1.7, 2.0, 1.2, 1.0];
/** @type {string} */ var vtxSource = '#version 300 es\n' +
'in highp vec4 a_position;\n' +
'void main (void)\n' +
'{\n' +
' gl_Position = a_position;\n' +
'}\n';
/** @type {string} */ var fragSource = '#version 300 es\n' +
'layout(location = 0) out mediump vec4 o_color;\n' +
'void main (void)\n' +
'{\n' +
' o_color = vec4(0.0, 1.0/gl_FragCoord.w - 1.0, 0.0, 1.0);\n' +
'}\n';
/** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource));
bufferedLogToConsole(program.getProgramInfo().infoLog);
if (!program.isOk())
throw new Error('Compile failed');
// Draw with GL.
/** @type {Array<number>} */ var positions = [
-w[0], w[0], 0.0, w[0],
-w[1], -w[1], 0.0, w[1],
w[2], w[2], 0.0, w[2],
w[3], -w[3], 0.0, w[3]
];
/** @type {Array<number>} */ var indices = [0, 1, 2, 2, 1, 3];
/** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, positions);
gl.useProgram(program.getProgram());
gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indices));
testImg.readViewport(gl, [0, 0, width, height]);
// Draw reference
for (var y = 0; y < refImg.getHeight(); y++) {
for (var x = 0; x < refImg.getWidth(); x++) {
/** @type {number} */ var xf = (x + 0.5) / refImg.getWidth();
/** @type {number} */ var yf = (refImg.getHeight() - y - 1 + 0.5) / refImg.getHeight();
/** @type {number} */ var oow = ((xf + yf) < 1.0) ?
es3fShaderBuiltinVarTests.projectedTriInterpolate([w[0], w[1], w[2]], [w[0], w[1], w[2]], xf, yf) :
es3fShaderBuiltinVarTests.projectedTriInterpolate([w[3], w[2], w[1]], [w[3], w[2], w[1]], 1.0 - xf, 1.0 - yf);
/** @type {Array<number>} */
var color = [
0,
deMath.clamp(Math.floor((oow - 1.0) * 255 + 0.5), 0, 255),
0,
255];
refImg.setPixel(x, y, color);
}
}
// Compare
/** @type {boolean} */ var isOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', refImg, testImg, threshold);
if (!isOk) {
testFailedOptions('Image comparison failed', false);
} else
testPassedOptions('Pass', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderBuiltinVarTests.PointCoordCase = function() {
tcuTestCase.DeqpTest.call(this, 'pointcoord', 'gl_PointCoord Test');
};
es3fShaderBuiltinVarTests.PointCoordCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.PointCoordCase.prototype.constructor = es3fShaderBuiltinVarTests.PointCoordCase;
/**
* @return {tcuTestCase.IterateResult}
*/
es3fShaderBuiltinVarTests.PointCoordCase.prototype.iterate = function() {
/** @type {number} */ var width = Math.min(256, gl.drawingBufferWidth);
/** @type {number} */ var height = Math.min(256, gl.drawingBufferHeight);
/** @type {number} */ var threshold = 0.02;
/** @type {number} */ var numPoints = 8;
/** @type {Array<number>} */ var coords = [];
/** @type {Array<number>} */ var pointSizeRange = [0.0, 0.0];
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(0x145fa);
/** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height);
/** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height);
pointSizeRange = /** @type {Array<number>} */ (gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE));
if (pointSizeRange[0] <= 0.0 || pointSizeRange[1] <= 0.0 || pointSizeRange[1] < pointSizeRange[0])
throw new Error('Invalid gl.ALIASED_POINT_SIZE_RANGE');
// Compute coordinates.
for (var i = 0; i < numPoints; i++)
coords.push([
rnd.getFloat(-0.9, 0.9),
rnd.getFloat(-0.9, 0.9),
rnd.getFloat(pointSizeRange[0], pointSizeRange[1])
]);
/** @type {string} */ var vtxSource = '#version 300 es\n' +
'in highp vec3 a_positionSize;\n' +
'void main (void)\n' +
'{\n' +
' gl_Position = vec4(a_positionSize.xy, 0.0, 1.0);\n' +
' gl_PointSize = a_positionSize.z;\n' +
'}\n';
/** @type {string} */ var fragSource = '#version 300 es\n' +
'layout(location = 0) out mediump vec4 o_color;\n' +
'void main (void)\n' +
'{\n' +
' o_color = vec4(gl_PointCoord, 0.0, 1.0);\n' +
'}\n';
/** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource));
bufferedLogToConsole(program.getProgramInfo().infoLog);
if (!program.isOk())
throw new Error('Compile failed');
// Draw with GL.
var newCoords = [].concat.apply([], coords);
// /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_positionSize', 3, coords.length, 0, coords);
/** @type {gluDrawUtil.VertexArrayBinding} */
var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_positionSize', 3, coords.length, 12, newCoords);
/** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - width);
/** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - height);
gl.viewport(viewportX, viewportY, width, height);
gl.clearColor(0.0, 0.0, 0.0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.useProgram(program.getProgram());
gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.pointsFromElements(coords.length));
testImg.readViewport(gl, [viewportX, viewportY, width, height]);
// Draw reference
refImg.getAccess().clear([0.0, 0.0, 0.0, 1.0]);
for (var i = 0; i < coords.length; i++) {
/** @type {number} */ var x0 = Math.round(width * (coords[i][0] * 0.5 + 0.5) - coords[i][2] * 0.5);
/** @type {number} */ var y0 = Math.round(height* (coords[i][1] * 0.5 + 0.5) - coords[i][2] * 0.5);
/** @type {number} */ var x1 = Math.round(width * (coords[i][0] * 0.5 + 0.5) + coords[i][2] * 0.5);
/** @type {number} */ var y1 = Math.round(height * (coords[i][1] * 0.5 + 0.5) + coords[i][2] * 0.5);
/** @type {number} */ var w = x1 - x0;
/** @type {number} */ var h = y1 - y0;
for (var yo = 0; yo < h; yo++) {
for (var xo = 0; xo < w; xo++) {
/** @type {number} */ var xf = (xo + 0.5) / w;
/** @type {number} */ var yf = ((h - yo - 1) + 0.5) / h;
/** @type {number} */ var dx = x0 + xo;
/** @type {number} */ var dy = y0 + yo;
/** @type {Array<number>} */
var color = [
deMath.clamp(Math.floor(xf * 255 + 0.5), 0, 255),
deMath.clamp(Math.floor(yf * 255 + 0.5), 0, 255),
0,
255];
if (deMath.deInBounds32(dx, 0, refImg.getWidth()) && deMath.deInBounds32(dy, 0, refImg.getHeight()))
refImg.setPixel(dx, dy, color);
}
}
}
// Compare
/** @type {boolean} */ var isOk = tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', refImg.getAccess(), testImg.getAccess(), threshold);
if (!isOk) {
testFailedOptions('Image comparison failed', false);
} else
testPassedOptions('Pass', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderBuiltinVarTests.FrontFacingCase = function() {
tcuTestCase.DeqpTest.call(this, 'frontfacing', 'gl_FrontFacing Test');
};
es3fShaderBuiltinVarTests.FrontFacingCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.FrontFacingCase.prototype.constructor = es3fShaderBuiltinVarTests.FrontFacingCase;
/**
* @return {tcuTestCase.IterateResult}
*/
es3fShaderBuiltinVarTests.FrontFacingCase.prototype.iterate = function() {
// Test case renders two adjecent quads, where left is has front-facing
// triagles and right back-facing. Color is selected based on gl_FrontFacing
// value.
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(0x89f2c);
/** @type {number} */ var width = Math.min(64, gl.drawingBufferWidth);
/** @type {number} */ var height = Math.min(64, gl.drawingBufferHeight);
/** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - width);
/** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - height);
/** @type {Array<number>} */ var threshold = deMath.add([1, 1, 1, 1], tcuPixelFormat.PixelFormatFromContext(gl).getColorThreshold());
/** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height);
/** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height);
/** @type {string} */ var vtxSource = '#version 300 es\n' +
'in highp vec4 a_position;\n' +
'void main (void)\n' +
'{\n' +
' gl_Position = a_position;\n' +
'}\n';
/** @type {string} */ var fragSource = '#version 300 es\n' +
'layout(location = 0) out mediump vec4 o_color;\n' +
'void main (void)\n' +
'{\n' +
' if (gl_FrontFacing)\n' +
' o_color = vec4(0.0, 1.0, 0.0, 1.0);\n' +
' else\n' +
' o_color = vec4(0.0, 0.0, 1.0, 1.0);\n' +
'}\n';
/** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource));
bufferedLogToConsole(program.getProgramInfo().infoLog);
if (!program.isOk())
throw new Error('Compile failed');
// Draw with GL.
/** @type {Array<number>} */ var positions = [
-1.0, 1.0, 0.0, 1.0,
-1.0, -1.0, 0.0, 1.0,
1.0, 1.0, 0.0, 1.0,
1.0, -1.0, 0.0, 1.0
];
/** @type {Array<number>} */ var indicesCCW = [0, 1, 2, 2, 1, 3];
/** @type {Array<number>} */ var indicesCW = [2, 1, 0, 3, 1, 2];
/** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, positions);
gl.useProgram(program.getProgram());
gl.viewport(viewportX, viewportY, Math.floor(width / 2), height);
gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indicesCCW));
gl.viewport(viewportX + Math.floor(width / 2), viewportY, width - Math.floor(width / 2), height);
gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indicesCW));
testImg.readViewport(gl, [viewportX, viewportY, width, height]);
// Draw reference
for (var y = 0; y < refImg.getHeight(); y++) {
for (var x = 0; x < Math.floor(refImg.getWidth() / 2); x++)
refImg.setPixel(x, y, tcuRGBA.RGBA.green.toIVec());
for (var x = Math.floor(refImg.getWidth() / 2); x < refImg.getWidth(); x++)
refImg.setPixel(x, y, tcuRGBA.RGBA.blue.toIVec());
}
// Compare
/** @type {boolean} */ var isOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', refImg, testImg, threshold);
if (!isOk) {
testFailedOptions('Image comparison failed', false);
} else
testPassedOptions('Pass', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderBuiltinVarTests.VertexIDCase = function() {
tcuTestCase.DeqpTest.call(this, 'vertex_id', 'gl_VertexID Test');
/** @type {?gluShaderProgram.ShaderProgram} */ this.m_program = null;
/** @type {WebGLBuffer} */ this.m_positionBuffer = null;
/** @type {WebGLBuffer} */ this.m_elementBuffer = null;
/** @type {number} */ this.m_viewportW = 0;
/** @type {number} */ this.m_viewportH = 0;
/** @type {number} */ this.m_iterNdx = 0;
/** @type {Array<Array<number>>} */ this.m_positions = [];
/** @type {Array<Array<number>>} */ this.m_colors = [];
};
es3fShaderBuiltinVarTests.VertexIDCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.VertexIDCase.prototype.constructor = es3fShaderBuiltinVarTests.VertexIDCase;
es3fShaderBuiltinVarTests.VertexIDCase.MAX_VERTICES = 24; //!< 8 triangles, totals 24 vertices
es3fShaderBuiltinVarTests.VertexIDCase.prototype.init = function() {
/** @type {number} */ var width = gl.drawingBufferWidth;
/** @type {number} */ var height = gl.drawingBufferHeight;
/** @type {number} */ var quadWidth = 32;
/** @type {number} */ var quadHeight = 32;
if (width < quadWidth)
throw new Error('Too small render target');
/** @type {number} */ var maxQuadsX = Math.floor(width / quadWidth);
/** @type {number} */ var numVertices = es3fShaderBuiltinVarTests.VertexIDCase.MAX_VERTICES;
/** @type {number} */ var numQuads = Math.floor(numVertices / 6) + (numVertices % 6 != 0 ? 1 : 0);
/** @type {number} */ var viewportW = Math.min(numQuads, maxQuadsX)*quadWidth;
/** @type {number} */ var viewportH = (Math.floor(numQuads/maxQuadsX) + (numQuads % maxQuadsX != 0 ? 1 : 0)) * quadHeight;
if (viewportH > height)
throw new Error('Too small render target');
assertMsgOptions(viewportW <= width && viewportH <= height, 'Unexpected viewport dimensions.', false, true);
assertMsgOptions(!this.m_program, 'Program should not be defined at this point.', false, true);
/** @type {string} */ var vtxSource = '#version 300 es\n' +
'in highp vec4 a_position;\n' +
'out mediump vec4 v_color;\n' +
'uniform highp vec4 u_colors[24];\n' +
'void main (void)\n' +
'{\n' +
' gl_Position = a_position;\n' +
' v_color = u_colors[gl_VertexID];\n' +
'}\n';
/** @type {string} */ var fragSource = '#version 300 es\n' +
'in mediump vec4 v_color;\n' +
'layout(location = 0) out mediump vec4 o_color;\n' +
'void main (void)\n' +
'{\n' +
' o_color = v_color;\n' +
'}\n';
this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource));
bufferedLogToConsole(this.m_program.getProgramInfo().infoLog);
if (!this.m_program.isOk()) {
this.m_program = null;
throw new Error('Compile failed');
}
this.m_positionBuffer = gl.createBuffer();
this.m_elementBuffer = gl.createBuffer();
// Set colors (in dynamic memory to save static data space).
this.m_colors[0] = [0.0, 0.0, 0.0, 1.0];
this.m_colors[1] = [0.5, 1.0, 0.5, 1.0];
this.m_colors[2] = [0.0, 0.5, 1.0, 1.0];
this.m_colors[3] = [0.0, 1.0, 0.0, 1.0];
this.m_colors[4] = [0.0, 1.0, 1.0, 1.0];
this.m_colors[5] = [0.5, 0.0, 0.0, 1.0];
this.m_colors[6] = [0.5, 0.0, 1.0, 1.0];
this.m_colors[7] = [0.5, 0.0, 0.5, 1.0];
this.m_colors[8] = [1.0, 0.0, 0.0, 1.0];
this.m_colors[9] = [0.5, 1.0, 0.0, 1.0];
this.m_colors[10] = [0.0, 0.5, 0.0, 1.0];
this.m_colors[11] = [0.5, 1.0, 1.0, 1.0];
this.m_colors[12] = [0.0, 0.0, 1.0, 1.0];
this.m_colors[13] = [1.0, 0.0, 0.5, 1.0];
this.m_colors[14] = [0.0, 0.5, 0.5, 1.0];
this.m_colors[15] = [1.0, 1.0, 0.5, 1.0];
this.m_colors[16] = [1.0, 0.0, 1.0, 1.0];
this.m_colors[17] = [1.0, 0.5, 0.0, 1.0];
this.m_colors[18] = [0.0, 1.0, 0.5, 1.0];
this.m_colors[19] = [1.0, 0.5, 1.0, 1.0];
this.m_colors[20] = [1.0, 1.0, 0.0, 1.0];
this.m_colors[21] = [1.0, 0.5, 0.5, 1.0];
this.m_colors[22] = [0.0, 0.0, 0.5, 1.0];
this.m_colors[23] = [1.0, 1.0, 1.0, 1.0];
// Compute positions.
assertMsgOptions(numVertices % 3 == 0, 'Number of vertices should be multiple of 3.', false, true);
for (var vtxNdx = 0; vtxNdx < numVertices; vtxNdx += 3) {
/** @type {number} */ var h = 2.0 * quadHeight / viewportH;
/** @type {number} */ var w = 2.0 * quadWidth / viewportW;
/** @type {number} */ var triNdx = Math.floor(vtxNdx / 3);
/** @type {number} */ var quadNdx = Math.floor(triNdx / 2);
/** @type {number} */ var quadY = Math.floor(quadNdx / maxQuadsX);
/** @type {number} */ var quadX = quadNdx % maxQuadsX;
/** @type {number} */ var x0 = -1.0 + quadX * w;
/** @type {number} */ var y0 = -1.0 + quadY * h;
if (triNdx % 2 === 0) {
this.m_positions[vtxNdx + 0] = [x0, y0, 0.0, 1.0];
this.m_positions[vtxNdx + 1] = [x0+w, y0+h, 0.0, 1.0];
this.m_positions[vtxNdx + 2] = [x0, y0+h, 0.0, 1.0];
} else {
this.m_positions[vtxNdx + 0] = [x0 + w, y0 + h, 0.0, 1.0];
this.m_positions[vtxNdx + 1] = [x0, y0, 0.0, 1.0];
this.m_positions[vtxNdx + 2] = [x0+w, y0, 0.0, 1.0];
}
}
this.m_viewportW = viewportW;
this.m_viewportH = viewportH;
this.m_iterNdx = 0;
};
es3fShaderBuiltinVarTests.VertexIDCase.prototype.deinit = function() {
this.m_program = null;
if (this.m_positionBuffer) {
gl.deleteBuffer(this.m_positionBuffer);
this.m_positionBuffer = null;
}
if (this.m_elementBuffer) {
gl.deleteBuffer(this.m_elementBuffer);
this.m_elementBuffer = null;
}
this.m_positions = [];
this.m_colors = [];
};
/**
* @constructor
* @extends {sglrShaderProgram.ShaderProgram}
*/
es3fShaderBuiltinVarTests.VertexIDReferenceShader = function() {
/** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var declaration = new sglrShaderProgram.ShaderProgramDeclaration();
declaration.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('', rrGenericVector.GenericVecType.FLOAT));
declaration.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('', rrGenericVector.GenericVecType.FLOAT));
declaration.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT, new sglrShaderProgram.VaryingFlags()));
declaration.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));
declaration.pushVertexSource(new sglrShaderProgram.VertexSource('')); // ShaderProgram fails if we don't push a source, even though GLSL source is not used
declaration.pushFragmentSource(new sglrShaderProgram.FragmentSource(''));
sglrShaderProgram.ShaderProgram.call(this, declaration);
};
es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype);
es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype.constructor = es3fShaderBuiltinVarTests.VertexIDReferenceShader;
/** @const {number} */ es3fShaderBuiltinVarTests.VertexIDReferenceShader.VARYINGLOC_COLOR = 0;
/**
* @param {Array<rrVertexAttrib.VertexAttrib>} inputs
* @param {Array<rrVertexPacket.VertexPacket>} packets
*/
es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype.shadeVertices = function(inputs, packets) {
for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) {
/** @type {number} */ var positionAttrLoc = 0;
/** @type {number} */ var colorAttrLoc = 1;
/** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx];
// Transform to position
packet.position = rrVertexAttrib.readVertexAttrib(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT);
// Pass color to FS
packet.outputs[es3fShaderBuiltinVarTests.VertexIDReferenceShader.VARYINGLOC_COLOR] = rrVertexAttrib.readVertexAttrib(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT);
}
};
/**
* @param {Array<rrFragmentOperations.Fragment>} packets
* @param {rrShadingContext.FragmentShadingContext} context
*/
es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype.shadeFragments = function(packets, context) {
for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) {
/** @type {rrFragmentOperations.Fragment} */ var packet = packets[packetNdx];
packet.value = rrShadingContext.readVarying(packet, context, es3fShaderBuiltinVarTests.VertexIDReferenceShader.VARYINGLOC_COLOR);
}
};
/**
* @param {tcuTexture.PixelBufferAccess} dst
* @param {Array<number>} indices
* @param {goog.NumberArray} positions
* @param {goog.NumberArray} colors
*/
es3fShaderBuiltinVarTests.VertexIDCase.prototype.renderReference = function(dst, indices, positions, colors) {
/** @type {rrRenderState.RenderState} */
var referenceState = new rrRenderState.RenderState(
new rrRenderState.ViewportState(rrMultisamplePixelBufferAccess.MultisamplePixelBufferAccess.fromSinglesampleAccess(dst))
);
/** @type {rrRenderer.RenderTarget} */
var referenceTarget = new rrRenderer.RenderTarget(
rrMultisamplePixelBufferAccess.MultisamplePixelBufferAccess.fromSinglesampleAccess(dst)
);
/** @type {es3fShaderBuiltinVarTests.VertexIDReferenceShader} */
var referenceShaderProgram = new es3fShaderBuiltinVarTests.VertexIDReferenceShader();
/** @type {Array<rrVertexAttrib.VertexAttrib>} */ var attribs = [];
attribs[0] = new rrVertexAttrib.VertexAttrib();
attribs[0].type = rrVertexAttrib.VertexAttribType.FLOAT;
attribs[0].size = 4;
attribs[0].stride = 0;
attribs[0].instanceDivisor = 0;
attribs[0].pointer = positions.buffer;
attribs[1] = new rrVertexAttrib.VertexAttrib();
attribs[1].type = rrVertexAttrib.VertexAttribType.FLOAT;
attribs[1].size = 4;
attribs[1].stride = 0;
attribs[1].instanceDivisor = 0;
attribs[1].pointer = colors.buffer;
rrRenderer.drawTriangles(referenceState, referenceTarget, referenceShaderProgram,
attribs, rrRenderer.PrimitiveType.TRIANGLES, 0, indices.length, /*instanceID = */ 0);
};
/**
* @return {tcuTestCase.IterateResult}
*/
es3fShaderBuiltinVarTests.VertexIDCase.prototype.iterate = function() {
/** @type {number} */ var width = gl.drawingBufferWidth;
/** @type {number} */ var height = gl.drawingBufferHeight;
/** @type {number} */ var viewportW = this.m_viewportW;
/** @type {number} */ var viewportH = this.m_viewportH;
/** @type {number} */ var threshold = 0.02;
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xcf23ab1 ^ deString.deStringHash(this.m_iterNdx.toString()));
/** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(viewportW, viewportH);
/** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(viewportW, viewportH);
/** @type {number} */ var viewportX = rnd.getInt(0, width - viewportW);
/** @type {number} */ var viewportY = rnd.getInt(0, height - viewportH);
/** @type {number} */ var posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position');
/** @type {WebGLUniformLocation} */ var colorsLoc = gl.getUniformLocation(this.m_program.getProgram(), 'u_colors[0]');
/** @type {Array<number>} */ var clearColor = [0.0, 0.0, 0.0, 1.0];
/** @type {Array<number>} */ var indices = [];
/** @type {Array<Array<number>>} */ var mappedPos = [];
/** @type {goog.NumberArray} */ var flatColorArray;
/** @type {goog.NumberArray} */ var flatPosArray;
// Setup common state.
gl.viewport(viewportX, viewportY, viewportW, viewportH);
gl.useProgram(this.m_program.getProgram());
gl.bindBuffer(gl.ARRAY_BUFFER, this.m_positionBuffer);
gl.enableVertexAttribArray(posLoc);
gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0);
gl.uniform4fv(colorsLoc, [].concat.apply([], this.m_colors));
// Clear render target to black.
gl.clearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
gl.clear(gl.COLOR_BUFFER_BIT);
refImg.getAccess().clear(clearColor);
if (this.m_iterNdx === 0) {
bufferedLogToConsole('Iter0: glDrawArrays()');
flatPosArray = new Float32Array([].concat.apply([], this.m_positions));
flatColorArray = new Float32Array([].concat.apply([], this.m_colors));
gl.bufferData(gl.ARRAY_BUFFER, flatPosArray.buffer, gl.DYNAMIC_DRAW);
gl.drawArrays(gl.TRIANGLES, 0, Math.floor(flatPosArray.length / 4));
//glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
testImg.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]);
// Reference indices
for (var ndx = 0; ndx < this.m_positions.length; ndx++)
indices.push(ndx);
this.renderReference(refImg.getAccess(), indices, flatPosArray, flatColorArray);
} else if (this.m_iterNdx === 1) {
bufferedLogToConsole('Iter1: glDrawElements(), indices in buffer');
// Compute initial indices and suffle
for (var ndx = 0; ndx < this.m_positions.length; ndx++)
indices.push(ndx);
// deRandom.shuffle(rnd, indices);
// \note [2015-08-05 dag] The original test shuffles the indices array but the reference renderer cannot handle triangles with sides not parallel to the axes.
// Use indices to re-map positions.
for (var ndx = 0; ndx < indices.length; ndx++)
mappedPos[indices[ndx]] = this.m_positions[ndx];
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.m_elementBuffer);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, (new Uint16Array(indices)).buffer, gl.DYNAMIC_DRAW);
flatPosArray = new Float32Array([].concat.apply([], mappedPos));
flatColorArray = new Float32Array([].concat.apply([], this.m_colors));
gl.bufferData(gl.ARRAY_BUFFER, flatPosArray.buffer, gl.DYNAMIC_DRAW);
gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
//glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
testImg.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]);
refImg.getAccess().clear(clearColor);
this.renderReference(refImg.getAccess(), indices, flatPosArray, flatColorArray);
} else
throw new Error('Iteration count exceeded.');
if (!tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', refImg.getAccess(), testImg.getAccess(), threshold))
testFailedOptions('Image comparison failed', false);
else
testPassedOptions('Pass', true);
this.m_iterNdx += 1;
return (this.m_iterNdx < 2) ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderBuiltinVarTests.ShaderBuiltinVarTests = function() {
tcuTestCase.DeqpTest.call(this, 'builtin_variable', 'Built-in Variable Tests');
};
es3fShaderBuiltinVarTests.ShaderBuiltinVarTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderBuiltinVarTests.ShaderBuiltinVarTests.prototype.constructor = es3fShaderBuiltinVarTests.ShaderBuiltinVarTests;
es3fShaderBuiltinVarTests.ShaderBuiltinVarTests.prototype.init = function() {
var testGroup = tcuTestCase.runner.testCases;
// Builtin constants.
/**
* @struct
* @constructor
* @param {string} caseName
* @param {string} varName
* @param {es3fShaderBuiltinVarTests.GetConstantValueFunc} getValue
*/
var BuiltinConstant = function(caseName, varName, getValue) {
/** @type {string} */ this.caseName = caseName;
/** @type {string} */ this.varName = varName;
/** @type {es3fShaderBuiltinVarTests.GetConstantValueFunc} */ this.getValue = getValue;
};
/** @type {Array<BuiltinConstant>} */ var builtinConstants = [
// GLES 2.
new BuiltinConstant('max_vertex_attribs', 'gl_MaxVertexAttribs', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_VERTEX_ATTRIBS); }),
new BuiltinConstant('max_vertex_uniform_vectors', 'gl_MaxVertexUniformVectors', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_VERTEX_UNIFORM_VECTORS); }),
new BuiltinConstant('max_fragment_uniform_vectors', 'gl_MaxFragmentUniformVectors', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_FRAGMENT_UNIFORM_VECTORS); }),
new BuiltinConstant('max_texture_image_units', 'gl_MaxTextureImageUnits', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_TEXTURE_IMAGE_UNITS); }),
new BuiltinConstant('max_vertex_texture_image_units', 'gl_MaxVertexTextureImageUnits', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS); }),
new BuiltinConstant('max_combined_texture_image_units', 'gl_MaxCombinedTextureImageUnits', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS); }),
new BuiltinConstant('max_draw_buffers', 'gl_MaxDrawBuffers', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_DRAW_BUFFERS); }),
// GLES 3.
new BuiltinConstant('max_vertex_output_vectors', 'gl_MaxVertexOutputVectors', function() { return es3fShaderBuiltinVarTests.getVectorsFromComps(gl.MAX_VERTEX_OUTPUT_COMPONENTS); }),
new BuiltinConstant('max_fragment_input_vectors', 'gl_MaxFragmentInputVectors', function() { return es3fShaderBuiltinVarTests.getVectorsFromComps(gl.MAX_FRAGMENT_INPUT_COMPONENTS); }),
new BuiltinConstant('min_program_texel_offset', 'gl_MinProgramTexelOffset', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MIN_PROGRAM_TEXEL_OFFSET); }),
new BuiltinConstant('max_program_texel_offset', 'gl_MaxProgramTexelOffset', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_PROGRAM_TEXEL_OFFSET); })
];
for (var ndx = 0; ndx < builtinConstants.length; ndx++) {
/** @type {string} */ var caseName = builtinConstants[ndx].caseName;
/** @type {string} */ var varName = builtinConstants[ndx].varName;
/** @type {es3fShaderBuiltinVarTests.GetConstantValueFunc} */ var getValue = builtinConstants[ndx].getValue;
testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase(caseName + '_vertex', varName, varName, getValue, gluShaderProgram.shaderType.VERTEX));
testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase(caseName + '_fragment', varName, varName, getValue, gluShaderProgram.shaderType.FRAGMENT));
}
testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderDepthRangeTest('depth_range_vertex', 'gl_DepthRange', true));
testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderDepthRangeTest('depth_range_fragment', 'gl_DepthRange', false));
// Vertex shader builtin variables.
testGroup.addChild(new es3fShaderBuiltinVarTests.VertexIDCase());
// \todo [2013-03-20 pyry] gl_InstanceID -- tested in instancing tests quite thoroughly.
// Fragment shader builtin variables.
testGroup.addChild(new es3fShaderBuiltinVarTests.FragCoordXYZCase());
testGroup.addChild(new es3fShaderBuiltinVarTests.FragCoordWCase());
testGroup.addChild(new es3fShaderBuiltinVarTests.PointCoordCase());
testGroup.addChild(new es3fShaderBuiltinVarTests.FrontFacingCase());
};
/**
* Run test
* @param {WebGL2RenderingContext} context
*/
es3fShaderBuiltinVarTests.run = function(context) {
gl = context;
//Set up Test Root parameters
var state = tcuTestCase.runner;
state.setRoot(new es3fShaderBuiltinVarTests.ShaderBuiltinVarTests());
//Set up name and description of this test series.
setCurrentTestName(state.testCases.fullName());
description(state.testCases.getDescription());
try {
//Run test cases
tcuTestCase.runTestCases();
}
catch (err) {
testFailedOptions('Failed to es3fShaderBuiltinVarTests.run tests', false);
tcuTestCase.runner.terminate();
}
};
});