mozilla-central/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fShaderIndexingTests.js (file symbol)

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.es3fShaderIndexingTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuStringTemplate');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluTexture');
goog.require('modules.shared.glsShaderRenderCase');
goog.scope(function() {
/** @type {?WebGL2RenderingContext} */ var gl;
var es3fShaderIndexingTests = functional.gles3.es3fShaderIndexingTests;
var deMath = framework.delibs.debase.deMath;
var glsShaderRenderCase = modules.shared.glsShaderRenderCase;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluTexture = framework.opengl.gluTexture;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var tcuTestCase = framework.common.tcuTestCase;
var tcuStringTemplate = framework.common.tcuStringTemplate;
/**
* @enum {number}
*/
es3fShaderIndexingTests.IndexAccessType = {
STATIC: 0,
DYNAMIC: 1,
STATIC_LOOP: 2,
DYNAMIC_LOOP: 3
};
/**
* @param {es3fShaderIndexingTests.IndexAccessType} accessType
* @return {string}
*/
es3fShaderIndexingTests.getIndexAccessTypeName = function(accessType) {
/** @type {Array<string>} */ var s_names = [
'static',
'dynamic',
'static_loop',
'dynamic_loop'
];
return s_names[accessType];
};
/**
* @enum {number}
*/
es3fShaderIndexingTests.VectorAccessType = {
DIRECT: 0,
COMPONENT: 1,
SUBSCRIPT_STATIC: 2,
SUBSCRIPT_DYNAMIC: 3,
SUBSCRIPT_STATIC_LOOP: 4,
SUBSCRIPT_DYNAMIC_LOOP: 5
};
/**
* @param {es3fShaderIndexingTests.VectorAccessType} accessType
* @return {string}
*/
es3fShaderIndexingTests.getVectorAccessTypeName = function(accessType) {
/** @type {Array<string>} */ var s_names = [
'direct',
'component',
'static_subscript',
'dynamic_subscript',
'static_loop_subscript',
'dynamic_loop_subscript'
];
assertMsgOptions(deMath.deInBounds32(accessType, 0, s_names.length), 'Index out of bounds', false, true);
return s_names[accessType];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayCoordsFloat = function(c) {
c.color[0] = 1.875 * c.coords[0];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayCoordsVec2 = function(c) {
var swizzled = deMath.swizzle(c.coords, [0, 1]);
c.color[0] = 1.875 * swizzled[0];
c.color[1] = 1.875 * swizzled[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayCoordsVec3 = function(c) {
var swizzled = deMath.swizzle(c.coords, [0, 1, 2]);
c.color[0] = 1.875 * swizzled[0];
c.color[1] = 1.875 * swizzled[1];
c.color[2] = 1.875 * swizzled[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayCoordsVec4 = function(c) {
c.color = deMath.scale(c.coords, 1.875);
};
/**
* @param {gluShaderUtil.DataType} dataType
* @return {function(glsShaderRenderCase.ShaderEvalContext)}
*/
es3fShaderIndexingTests.getArrayCoordsEvalFunc = function(dataType) {
if (dataType === gluShaderUtil.DataType.FLOAT) return es3fShaderIndexingTests.evalArrayCoordsFloat;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC2) return es3fShaderIndexingTests.evalArrayCoordsVec2;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC3) return es3fShaderIndexingTests.evalArrayCoordsVec3;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC4) return es3fShaderIndexingTests.evalArrayCoordsVec4;
else throw new Error('Invalid data type.');
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayUniformFloat = function(c) {
c.color[0] = 1.875 * c.constCoords[0];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayUniformVec2 = function(c) {
var swizzled = deMath.swizzle(c.constCoords, [0, 1]);
c.color[0] = 1.875 * swizzled[0];
c.color[1] = 1.875 * swizzled[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayUniformVec3 = function(c) {
var swizzled = deMath.swizzle(c.constCoords, [0, 1, 2]);
c.color[0] = 1.875 * swizzled[0];
c.color[1] = 1.875 * swizzled[1];
c.color[2] = 1.875 * swizzled[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalArrayUniformVec4 = function(c) {
c.color = deMath.scale(c.constCoords, 1.875);
};
/**
* @param {gluShaderUtil.DataType} dataType
* @return {function(glsShaderRenderCase.ShaderEvalContext)}
*/
es3fShaderIndexingTests.getArrayUniformEvalFunc = function(dataType) {
if (dataType === gluShaderUtil.DataType.FLOAT) return es3fShaderIndexingTests.evalArrayUniformFloat;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC2) return es3fShaderIndexingTests.evalArrayUniformVec2;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC3) return es3fShaderIndexingTests.evalArrayUniformVec3;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC4) return es3fShaderIndexingTests.evalArrayUniformVec4;
else throw new Error('Invalid data type.');
};
/**
* @constructor
* @extends {glsShaderRenderCase.ShaderRenderCase}
* @param {string} name
* @param {string} description
* @param {boolean} isVertexCase
* @param {gluShaderUtil.DataType} varType
* @param {function(glsShaderRenderCase.ShaderEvalContext)} evalFunc
* @param {string} vertShaderSource
* @param {string} fragShaderSource
*/
es3fShaderIndexingTests.ShaderIndexingCase = function(name, description, isVertexCase, varType, evalFunc, vertShaderSource, fragShaderSource) {
glsShaderRenderCase.ShaderRenderCase.call(this, name, description, isVertexCase, evalFunc);
/** @type {gluShaderUtil.DataType} */ this.m_varType = varType;
/** @type {string} */ this.m_vertShaderSource = vertShaderSource;
/** @type {string} */ this.m_fragShaderSource = fragShaderSource;
};
es3fShaderIndexingTests.ShaderIndexingCase.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype);
es3fShaderIndexingTests.ShaderIndexingCase.prototype.constructor = es3fShaderIndexingTests.ShaderIndexingCase;
/**
* @param {?WebGLProgram} programID
* @param {Array<number>} constCoords
*/
es3fShaderIndexingTests.ShaderIndexingCase.prototype.setupUniforms = function(programID, constCoords) {
/** @type {(Array<number>|Float32Array)} */ var arr = [];
/** @type {Array<number>} */ var array1d = [];
/** @type {?WebGLUniformLocation} */ var arrLoc = gl.getUniformLocation(programID, 'u_arr');
if (arrLoc != null) {
if (this.m_varType === gluShaderUtil.DataType.FLOAT) {
arr[0] = constCoords[0];
arr[1] = constCoords[0] * 0.5;
arr[2] = constCoords[0] * 0.25;
arr[3] = constCoords[0] * 0.125;
gl.uniform1fv(arrLoc, arr);
}
else if (this.m_varType === gluShaderUtil.DataType.FLOAT_VEC2) {
arr[0] = deMath.swizzle(constCoords, [0, 1]);
arr[1] = deMath.scale(deMath.swizzle(constCoords, [0, 1]), 0.5);
arr[2] = deMath.scale(deMath.swizzle(constCoords, [0, 1]), 0.25);
arr[3] = deMath.scale(deMath.swizzle(constCoords, [0, 1]), 0.125);
for (var i = 0; i < arr.length; i++)
array1d = array1d.concat(arr[i]);
gl.uniform2fv(arrLoc, array1d);
}
else if (this.m_varType === gluShaderUtil.DataType.FLOAT_VEC3) {
arr[0] = deMath.swizzle(constCoords, [0, 1, 2]);
arr[1] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2]), 0.5);
arr[2] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2]), 0.25);
arr[3] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2]), 0.125);
for (var i = 0; i < arr.length; i++)
array1d = array1d.concat(arr[i]);
gl.uniform3fv(arrLoc, array1d);
}
else if (this.m_varType === gluShaderUtil.DataType.FLOAT_VEC4) {
arr[0] = deMath.swizzle(constCoords, [0,1,2,3]);
arr[1] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2, 3]), 0.5);
arr[2] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2, 3]), 0.25);
arr[3] = deMath.scale(deMath.swizzle(constCoords, [0, 1, 2, 3]), 0.125);
for (var i = 0; i < arr.length; i++)
array1d = array1d.concat(arr[i]);
gl.uniform4fv(arrLoc, array1d);
}
else
throw new Error('u_arr should not have location assigned in this test case');
}
};
/**
* @param {string} caseName
* @param {string} description
* @param {gluShaderUtil.DataType} varType
* @param {es3fShaderIndexingTests.IndexAccessType} vertAccess
* @param {es3fShaderIndexingTests.IndexAccessType} fragAccess
* @return {es3fShaderIndexingTests.ShaderIndexingCase}
*/
es3fShaderIndexingTests.createVaryingArrayCase = function(caseName, description, varType, vertAccess, fragAccess) {
/** @type {string} */ var vtx = '';
vtx += '#version 300 es\n' +
'in highp vec4 a_position;\n' +
'in highp vec4 a_coords;\n';
if (vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
vtx += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
else if (vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
vtx += 'uniform mediump int ui_four;\n';
vtx += 'out ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n' +
'\n' +
'void main()\n' +
'{\n' +
' gl_Position = a_position;\n';
if (vertAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
vtx += ' var[0] = ${VAR_TYPE}(a_coords);\n' +
' var[1] = ${VAR_TYPE}(a_coords) * 0.5;\n' +
' var[2] = ${VAR_TYPE}(a_coords) * 0.25;\n' +
' var[3] = ${VAR_TYPE}(a_coords) * 0.125;\n';
}
else if (vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
vtx += ' var[ui_zero] = ${VAR_TYPE}(a_coords);\n' +
' var[ui_one] = ${VAR_TYPE}(a_coords) * 0.5;\n' +
' var[ui_two] = ${VAR_TYPE}(a_coords) * 0.25;\n' +
' var[ui_three] = ${VAR_TYPE}(a_coords) * 0.125;\n';
}
else if (vertAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
vtx += ' ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n' +
' for (int i = 0; i < 4; i++)\n' +
' {\n' +
' var[i] = ${VAR_TYPE}(coords);\n' +
' coords = coords * 0.5;\n' +
' }\n';
}
else {
assertMsgOptions(vertAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'Not Dynamic_Loop', false, true);
vtx += ' ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n' +
' for (int i = 0; i < ui_four; i++)\n' +
' {\n' +
' var[i] = ${VAR_TYPE}(coords);\n' +
' coords = coords * 0.5;\n' +
' }\n';
}
vtx += '}\n';
/** @type {string} */ var frag = '';
frag += '#version 300 es\n' +
'precision mediump int;\n' +
'layout(location = 0) out mediump vec4 o_color;\n';
if (fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
frag += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
else if (fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
frag += 'uniform int ui_four;\n';
frag += 'in ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n' +
'\n' +
'void main()\n' +
'{\n' +
' ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n';
if (fragAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
frag += ' res += var[0];\n' +
' res += var[1];\n' +
' res += var[2];\n' +
' res += var[3];\n';
}
else if (fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
frag += ' res += var[ui_zero];\n' +
' res += var[ui_one];\n' +
' res += var[ui_two];\n' +
' res += var[ui_three];\n';
}
else if (fragAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
frag += ' for (int i = 0; i < 4; i++)\n' +
' res += var[i];\n';
}
else {
assertMsgOptions(fragAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'Not Dynamic_Loop', false, true);
frag += ' for (int i = 0; i < ui_four; i++)\n' +
' res += var[i];\n';
}
frag += ' o_color = vec4(res${PADDING});\n' +
'}\n';
// Fill in shader templates.
/** @type {Object} */ var params = {};
params['VAR_TYPE'] = gluShaderUtil.getDataTypeName(varType);
params['ARRAY_LEN'] = '4';
params['PRECISION'] = 'mediump';
if (varType === gluShaderUtil.DataType.FLOAT)
params['PADDING'] = ', 0.0, 0.0, 1.0';
else if (varType === gluShaderUtil.DataType.FLOAT_VEC2)
params['PADDING'] = ', 0.0, 1.0';
else if (varType === gluShaderUtil.DataType.FLOAT_VEC3)
params['PADDING'] = ', 1.0';
else
params['PADDING'] = '';
/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);
/** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
var evalFunc = es3fShaderIndexingTests.getArrayCoordsEvalFunc(varType);
return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, true, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
};
/**
* @param {string} caseName
* @param {string} description
* @param {boolean} isVertexCase
* @param {gluShaderUtil.DataType} varType
* @param {es3fShaderIndexingTests.IndexAccessType} readAccess
* @return {es3fShaderIndexingTests.ShaderIndexingCase}
*/
es3fShaderIndexingTests.createUniformArrayCase = function(caseName, description, isVertexCase, varType, readAccess) {
/** @type {string} */ var vtx = '';
/** @type {string} */ var frag = '';
/** @type {string} */ var op = '';
vtx += '#version 300 es\n';
frag += '#version 300 es\n';
vtx += 'in highp vec4 a_position;\n';
vtx += 'in highp vec4 a_coords;\n';
frag += 'layout(location = 0) out mediump vec4 o_color;\n';
if (isVertexCase) {
vtx += 'out mediump vec4 v_color;\n';
frag += 'in mediump vec4 v_color;\n';
}
else {
vtx += 'out mediump vec4 v_coords;\n';
frag += 'in mediump vec4 v_coords;\n';
}
if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
op += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
op += 'uniform mediump int ui_four;\n';
op += 'uniform ${PRECISION} ${VAR_TYPE} u_arr[${ARRAY_LEN}];\n';
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
vtx += '\n';
vtx += 'void main()\n';
vtx += '{\n';
vtx += ' gl_Position = a_position;\n';
frag += '\n';
frag += 'void main()\n';
frag += '{\n';
// Read array.
op += ' ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n';
if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
op += ' res += u_arr[0];\n';
op += ' res += u_arr[1];\n';
op += ' res += u_arr[2];\n';
op += ' res += u_arr[3];\n';
}
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
op += ' res += u_arr[ui_zero];\n';
op += ' res += u_arr[ui_one];\n';
op += ' res += u_arr[ui_two];\n';
op += ' res += u_arr[ui_three];\n';
}
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
op += ' for (int i = 0; i < 4; i++)\n';
op += ' res += u_arr[i];\n';
}
else {
assertMsgOptions(readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'readAccess not supported.', false, true);
op += ' for (int i = 0; i < ui_four; i++)\n';
op += ' res += u_arr[i];\n';
}
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
if (isVertexCase) {
vtx += ' v_color = vec4(res${PADDING});\n';
frag += ' o_color = v_color;\n';
}
else {
vtx += ' v_coords = a_coords;\n';
frag += ' o_color = vec4(res${PADDING});\n';
}
vtx += '}\n';
frag += '}\n';
// Fill in shader templates.
/** @type {Object} */ var params = {};
params['VAR_TYPE'] = gluShaderUtil.getDataTypeName(varType);
params['ARRAY_LEN'] = '4';
params['PRECISION'] = 'mediump';
if (varType === gluShaderUtil.DataType.FLOAT)
params['PADDING'] = ', 0.0, 0.0, 1.0';
else if (varType === gluShaderUtil.DataType.FLOAT_VEC2)
params['PADDING'] = ', 0.0, 1.0';
else if (varType === gluShaderUtil.DataType.FLOAT_VEC3)
params['PADDING'] = ', 1.0';
else
params['PADDING'] = '';
/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);
/** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
var evalFunc = es3fShaderIndexingTests.getArrayUniformEvalFunc(varType);
return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
};
/**
* @param {string} caseName
* @param {string} description
* @param {boolean} isVertexCase
* @param {gluShaderUtil.DataType} varType
* @param {es3fShaderIndexingTests.IndexAccessType} writeAccess
* @param {es3fShaderIndexingTests.IndexAccessType} readAccess
* @return {es3fShaderIndexingTests.ShaderIndexingCase}
*/
es3fShaderIndexingTests.createTmpArrayCase = function(caseName, description, isVertexCase, varType, writeAccess, readAccess) {
/** @type {string} */ var vtx = '';
/** @type {string} */ var frag = '';
/** @type {string} */ var op = '';
vtx += '#version 300 es\n';
frag += '#version 300 es\n';
vtx += 'in highp vec4 a_position;\n' +
'in highp vec4 a_coords;\n';
frag += 'layout(location = 0) out mediump vec4 o_color;\n';
if (isVertexCase) {
vtx += 'out mediump vec4 v_color;\n';
frag += 'in mediump vec4 v_color;\n';
}
else {
vtx += 'out mediump vec4 v_coords;\n';
frag += 'in mediump vec4 v_coords;\n';
}
if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC)
op += 'uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n';
if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
op += 'uniform mediump int ui_four;\n';
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
vtx += '\n' +
'void main()\n' +
'{\n' +
' gl_Position = a_position;\n';
frag += '\n' +
'void main()\n' +
'{\n';
// Write array.
if (isVertexCase)
op += ' ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n';
else
op += ' ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n';
op += ' ${PRECISION} ${VAR_TYPE} arr[${ARRAY_LEN}];\n';
if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
op += ' arr[0] = ${VAR_TYPE}(coords);\n' +
' arr[1] = ${VAR_TYPE}(coords) * 0.5;\n' +
' arr[2] = ${VAR_TYPE}(coords) * 0.25;\n' +
' arr[3] = ${VAR_TYPE}(coords) * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
op += ' arr[ui_zero] = ${VAR_TYPE}(coords);\n' +
' arr[ui_one] = ${VAR_TYPE}(coords) * 0.5;\n' +
' arr[ui_two] = ${VAR_TYPE}(coords) * 0.25;\n' +
' arr[ui_three] = ${VAR_TYPE}(coords) * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
op += ' for (int i = 0; i < 4; i++)\n' +
' {\n' +
' arr[i] = ${VAR_TYPE}(coords);\n' +
' coords = coords * 0.5;\n' +
' }\n';
}
else {
assertMsgOptions(writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'writeAccess not supported', false, true);
op += ' for (int i = 0; i < ui_four; i++)\n' +
' {\n' +
' arr[i] = ${VAR_TYPE}(coords);\n' +
' coords = coords * 0.5;\n' +
' }\n';
}
// Read array.
op += ' ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n';
if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
op += ' res += arr[0];\n' +
' res += arr[1];\n' +
' res += arr[2];\n' +
' res += arr[3];\n';
}
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
op += ' res += arr[ui_zero];\n' +
' res += arr[ui_one];\n' +
' res += arr[ui_two];\n' +
' res += arr[ui_three];\n';
}
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
op += ' for (int i = 0; i < 4; i++)\n' +
' res += arr[i];\n';
}
else {
assertMsgOptions(readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'readAccess not supported.', false, true);
op += ' for (int i = 0; i < ui_four; i++)\n' +
' res += arr[i];\n';
}
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
if (isVertexCase) {
vtx += ' v_color = vec4(res${PADDING});\n';
frag += ' o_color = v_color;\n';
}
else {
vtx += ' v_coords = a_coords;\n';
frag += ' o_color = vec4(res${PADDING});\n';
}
vtx += '}\n';
frag += '}\n';
// Fill in shader templates.
/** @type {Object} */ var params = {};
params["VAR_TYPE"] = gluShaderUtil.getDataTypeName(varType);
params["ARRAY_LEN"] = "4";
params["PRECISION"] = "mediump";
if (varType === gluShaderUtil.DataType.FLOAT)
params['PADDING'] = ', 0.0, 0.0, 1.0';
else if (varType === gluShaderUtil.DataType.FLOAT_VEC2)
params['PADDING'] = ', 0.0, 1.0';
else if (varType === gluShaderUtil.DataType.FLOAT_VEC3)
params['PADDING'] = ', 1.0';
else
params['PADDING'] = '';
/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);
/** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
var evalFunc = es3fShaderIndexingTests.getArrayCoordsEvalFunc(varType);
return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
};
// VECTOR SUBSCRIPT.
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptVec2 = function(c) {
c.color[0] = c.coords[0] + 0.5 * c.coords[1];
c.color[1] = c.coords[0] + 0.5 * c.coords[1];
c.color[2] = c.coords[0] + 0.5 * c.coords[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptVec3 = function(c) {
c.color[0] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2];
c.color[1] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2];
c.color[2] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptVec4 = function(c) {
c.color[0] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2] + 0.125 * c.coords[3];
c.color[1] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2] + 0.125 * c.coords[3];
c.color[2] = c.coords[0] + 0.5 * c.coords[1] + 0.25 * c.coords[2] + 0.125 * c.coords[3];
};
/**
* @param {gluShaderUtil.DataType} dataType
* @return {function(glsShaderRenderCase.ShaderEvalContext)}
*/
es3fShaderIndexingTests.getVectorSubscriptEvalFunc = function(dataType) {
if (dataType === gluShaderUtil.DataType.FLOAT_VEC2) return es3fShaderIndexingTests.evalSubscriptVec2;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC3) return es3fShaderIndexingTests.evalSubscriptVec3;
else if (dataType === gluShaderUtil.DataType.FLOAT_VEC4) return es3fShaderIndexingTests.evalSubscriptVec4;
else throw new Error('Invalid data type.');
};
/**
* @param {string} caseName
* @param {string} description
* @param {boolean} isVertexCase
* @param {gluShaderUtil.DataType} varType
* @param {es3fShaderIndexingTests.VectorAccessType} writeAccess
* @param {es3fShaderIndexingTests.VectorAccessType} readAccess
* @return {es3fShaderIndexingTests.ShaderIndexingCase}
*/
es3fShaderIndexingTests.createVectorSubscriptCase = function(caseName, description, isVertexCase, varType, writeAccess, readAccess) {
/** @type {string} */ var vtx = '';
/** @type {string} */ var frag = '';
/** @type {string} */ var op = '' ;
/** @type {number} */ var vecLen = gluShaderUtil.getDataTypeScalarSize(varType);
/** @type {string} */ var vecLenName = glsShaderRenderCase.getIntUniformName(vecLen);
vtx += '#version 300 es\n';
frag += '#version 300 es\n';
vtx += 'in highp vec4 a_position;\n' +
'in highp vec4 a_coords;\n';
frag += 'layout(location = 0) out mediump vec4 o_color;\n';
if (isVertexCase) {
vtx += 'out mediump vec3 v_color;\n';
frag += 'in mediump vec3 v_color;\n';
}
else {
vtx += 'out mediump vec4 v_coords;\n';
frag += 'in mediump vec4 v_coords;\n';
}
if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC ||
readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC){
op += 'uniform mediump int ui_zero';
if (vecLen >= 2) op += ', ui_one';
if (vecLen >= 3) op += ', ui_two';
if (vecLen >= 4) op += ', ui_three';
op += ';\n';
}
if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP ||
readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP)
op += 'uniform mediump int ' + vecLenName + ';\n';
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
vtx += '\n' +
'void main()\n' +
'{\n' +
' gl_Position = a_position;\n';
frag += '\n' +
'void main()\n' +
'{\n';
// Write vector.
if (isVertexCase)
op += ' ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n';
else
op += ' ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n';
op += ' ${PRECISION} ${VAR_TYPE} tmp;\n';
if (writeAccess === es3fShaderIndexingTests.VectorAccessType.DIRECT)
op += ' tmp = coords.${SWIZZLE} * vec4(1.0, 0.5, 0.25, 0.125).${SWIZZLE};\n';
else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.COMPONENT) {
op += ' tmp.x = coords.x;\n';
if (vecLen >= 2) op += ' tmp.y = coords.y * 0.5;\n';
if (vecLen >= 3) op += ' tmp.z = coords.z * 0.25;\n';
if (vecLen >= 4) op += ' tmp.w = coords.w * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC) {
op += ' tmp[0] = coords.x;\n';
if (vecLen >= 2) op += ' tmp[1] = coords.y * 0.5;\n';
if (vecLen >= 3) op += ' tmp[2] = coords.z * 0.25;\n';
if (vecLen >= 4) op += ' tmp[3] = coords.w * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC) {
op += ' tmp[ui_zero] = coords.x;\n';
if (vecLen >= 2) op += ' tmp[ui_one] = coords.y * 0.5;\n';
if (vecLen >= 3) op += ' tmp[ui_two] = coords.z * 0.25;\n';
if (vecLen >= 4) op += ' tmp[ui_three] = coords.w * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC_LOOP) {
op += ' for (int i = 0; i < ' + vecLen + '; i++)\n';
op += ' {\n';
op += ' tmp[i] = coords.x;\n';
op += ' coords = coords.${ROT_SWIZZLE} * 0.5;\n';
op += ' }\n';
}
else {
assertMsgOptions(writeAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP, 'writeAccess not supported.', false, true);
op += ' for (int i = 0; i < ' + vecLenName + '; i++)\n';
op += ' {\n';
op += ' tmp[i] = coords.x;\n';
op += ' coords = coords.${ROT_SWIZZLE} * 0.5;\n';
op += ' }\n';
}
// Read vector.
op += ' ${PRECISION} float res = 0.0;\n';
if (readAccess === es3fShaderIndexingTests.VectorAccessType.DIRECT)
op += ' res = dot(tmp, ${VAR_TYPE}(1.0));\n';
else if (readAccess === es3fShaderIndexingTests.VectorAccessType.COMPONENT) {
op += ' res += tmp.x;\n';
if (vecLen >= 2) op += ' res += tmp.y;\n';
if (vecLen >= 3) op += ' res += tmp.z;\n';
if (vecLen >= 4) op += ' res += tmp.w;\n';
}
else if (readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC) {
op += ' res += tmp[0];\n';
if (vecLen >= 2) op += ' res += tmp[1];\n';
if (vecLen >= 3) op += ' res += tmp[2];\n';
if (vecLen >= 4) op += ' res += tmp[3];\n';
}
else if (readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC) {
op += ' res += tmp[ui_zero];\n';
if (vecLen >= 2) op += ' res += tmp[ui_one];\n';
if (vecLen >= 3) op += ' res += tmp[ui_two];\n';
if (vecLen >= 4) op += ' res += tmp[ui_three];\n';
}
else if (readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_STATIC_LOOP) {
op += ' for (int i = 0; i < ' + vecLen + '; i++)\n';
op += ' res += tmp[i];\n';
}
else {
assertMsgOptions(readAccess === es3fShaderIndexingTests.VectorAccessType.SUBSCRIPT_DYNAMIC_LOOP, 'readAccess not supported', false, true);
op += ' for (int i = 0; i < ' + vecLenName + '; i++)\n';
op += ' res += tmp[i];\n';
}
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
if (isVertexCase) {
vtx += ' v_color = vec3(res);\n';
frag += ' o_color = vec4(v_color.rgb, 1.0);\n';
}
else {
vtx += ' v_coords = a_coords;\n';
frag += ' o_color = vec4(vec3(res), 1.0);\n';
}
vtx += '}\n';
frag += '}\n';
// Fill in shader templates.
/** @type {Array<string>} */ var s_swizzles = ['', 'x', 'xy', 'xyz', 'xyzw'];
/** @type {Array<string>} */ var s_rotSwizzles = ['', 'x', 'yx', 'yzx', 'yzwx'];
/** @type {Object} */ var params = {};
params["VAR_TYPE"] = gluShaderUtil.getDataTypeName(varType);
params["PRECISION"] = "mediump";
params["SWIZZLE"] = s_swizzles[vecLen];
params["ROT_SWIZZLE"] = s_rotSwizzles[vecLen];
/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);
/** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
var evalFunc = es3fShaderIndexingTests.getVectorSubscriptEvalFunc(varType);
return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
};
// MATRIX SUBSCRIPT.
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat2 = function(c) {
var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
var swizzle12 = deMath.swizzle(c.coords, [1, 2]);
c.color[0] = swizzle01[0] + 0.5 * swizzle12[0];
c.color[1] = swizzle01[1] + 0.5 * swizzle12[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat2x3 = function(c) {
var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
var swizzle123 = deMath.swizzle(c.coords, [1, 2, 3]);
c.color[0] = swizzle012[0] + 0.5 * swizzle123[0];
c.color[1] = swizzle012[1] + 0.5 * swizzle123[1];
c.color[2] = swizzle012[2] + 0.5 * swizzle123[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat2x4 = function(c) {
c.color = deMath.add(
deMath.swizzle(c.coords, [0,1,2,3]),
deMath.scale(deMath.swizzle(c.coords, [1,2,3,0]), 0.5));
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat3x2 = function(c) {
var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
var swizzle12 = deMath.swizzle(c.coords, [1, 2]);
var swizzle23 = deMath.swizzle(c.coords, [2, 3]);
c.color[0] = swizzle01[0] + 0.5 * swizzle12[0] + 0.25 * swizzle23[0];
c.color[1] = swizzle01[1] + 0.5 * swizzle12[1] + 0.25 * swizzle23[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat3 = function(c) {
var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
var swizzle123 = deMath.swizzle(c.coords, [1, 2, 3]);
var swizzle230 = deMath.swizzle(c.coords, [2, 3, 0]);
c.color[0] = swizzle012[0] + 0.5 * swizzle123[0] + 0.25 * swizzle230[0];
c.color[1] = swizzle012[1] + 0.5 * swizzle123[1] + 0.25 * swizzle230[1];
c.color[2] = swizzle012[2] + 0.5 * swizzle123[2] + 0.25 * swizzle230[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat3x4 = function(c) {
var swizzle0123 = deMath.swizzle(c.coords, [0, 1, 2, 3]);
var swizzle1230 = deMath.swizzle(c.coords, [1, 2, 3, 0]);
var swizzle2301 = deMath.swizzle(c.coords, [2, 3, 0, 1]);
c.color = deMath.add(
swizzle0123,
deMath.add(
deMath.scale(swizzle1230, 0.5),
deMath.scale(swizzle2301, 0.25)));
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat4x2 = function(c) {
var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
var swizzle12 = deMath.swizzle(c.coords, [1, 2]);
var swizzle23 = deMath.swizzle(c.coords, [2, 3]);
var swizzle30 = deMath.swizzle(c.coords, [3, 0]);
c.color[0] = swizzle01[0] + 0.5 * swizzle12[0] + 0.25 * swizzle23[0] + 0.125 * swizzle30[0];
c.color[1] = swizzle01[1] + 0.5 * swizzle12[1] + 0.25 * swizzle23[1] + 0.125 * swizzle30[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat4x3 = function(c) {
var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
var swizzle123 = deMath.swizzle(c.coords, [1, 2, 3]);
var swizzle230 = deMath.swizzle(c.coords, [2, 3, 0]);
var swizzle301 = deMath.swizzle(c.coords, [3, 0, 1]);
c.color[0] = swizzle012[0] + 0.5 * swizzle123[0] + 0.25 * swizzle230[0] + 0.125 * swizzle301[0];
c.color[1] = swizzle012[1] + 0.5 * swizzle123[1] + 0.25 * swizzle230[1] + 0.125 * swizzle301[1];
c.color[2] = swizzle012[2] + 0.5 * swizzle123[2] + 0.25 * swizzle230[2] + 0.125 * swizzle301[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
es3fShaderIndexingTests.evalSubscriptMat4 = function(c) {
var swizzle1230 = deMath.swizzle(c.coords, [1, 2, 3, 0]);
var swizzle2301 = deMath.swizzle(c.coords, [2, 3, 0, 1]);
var swizzle3012 = deMath.swizzle(c.coords, [3, 0, 1, 2]);
c.color = deMath.add(
c.coords,
deMath.add(
deMath.scale(swizzle1230, 0.5),
deMath.add(
deMath.scale(swizzle2301, 0.25),
deMath.scale(swizzle3012, 0.125))));
};
/**
* @param {gluShaderUtil.DataType} dataType
* @return {function(glsShaderRenderCase.ShaderEvalContext)}
*/
es3fShaderIndexingTests.getMatrixSubscriptEvalFunc = function(dataType) {
switch (dataType) {
case gluShaderUtil.DataType.FLOAT_MAT2: return es3fShaderIndexingTests.evalSubscriptMat2;
case gluShaderUtil.DataType.FLOAT_MAT2X3: return es3fShaderIndexingTests.evalSubscriptMat2x3;
case gluShaderUtil.DataType.FLOAT_MAT2X4: return es3fShaderIndexingTests.evalSubscriptMat2x4;
case gluShaderUtil.DataType.FLOAT_MAT3X2: return es3fShaderIndexingTests.evalSubscriptMat3x2;
case gluShaderUtil.DataType.FLOAT_MAT3: return es3fShaderIndexingTests.evalSubscriptMat3;
case gluShaderUtil.DataType.FLOAT_MAT3X4: return es3fShaderIndexingTests.evalSubscriptMat3x4;
case gluShaderUtil.DataType.FLOAT_MAT4X2: return es3fShaderIndexingTests.evalSubscriptMat4x2;
case gluShaderUtil.DataType.FLOAT_MAT4X3: return es3fShaderIndexingTests.evalSubscriptMat4x3;
case gluShaderUtil.DataType.FLOAT_MAT4: return es3fShaderIndexingTests.evalSubscriptMat4;
default:
throw new Error('Invalid data type.');
}
};
/**
* @param {string} caseName
* @param {string} description
* @param {boolean} isVertexCase
* @param {gluShaderUtil.DataType} varType
* @param {es3fShaderIndexingTests.IndexAccessType} writeAccess
* @param {es3fShaderIndexingTests.IndexAccessType} readAccess
* @return {es3fShaderIndexingTests.ShaderIndexingCase}
*/
es3fShaderIndexingTests.createMatrixSubscriptCase = function(caseName, description, isVertexCase, varType, writeAccess, readAccess) {
/** @type {string} */ var vtx = '';
/** @type {string} */ var frag = '';
/** @type {string} */ var op = '';
/** @type {number} */ var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(varType);
/** @type {number} */ var numRows = gluShaderUtil.getDataTypeMatrixNumRows(varType);
/** @type {string} */ var matSizeName = glsShaderRenderCase.getIntUniformName(numCols);
/** @type {gluShaderUtil.DataType} */ var vecType = gluShaderUtil.getDataTypeFloatVec(numRows);
vtx += '#version 300 es\n';
frag += '#version 300 es\n';
vtx += 'in highp vec4 a_position;\n' +
'in highp vec4 a_coords;\n';
frag += 'layout(location = 0) out mediump vec4 o_color;\n';
if (isVertexCase) {
vtx += 'out mediump vec4 v_color;\n';
frag += 'in mediump vec4 v_color;\n';
}
else {
vtx += 'out mediump vec4 v_coords;\n';
frag += 'in mediump vec4 v_coords;\n';
}
if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
op += 'uniform mediump int ui_zero';
if (numCols >= 2) op += ', ui_one';
if (numCols >= 3) op += ', ui_two';
if (numCols >= 4) op += ', ui_three';
op += ';\n';
}
if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP || readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP)
op += 'uniform mediump int ' + matSizeName + ';\n';
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
vtx += '\n' +
'void main()\n' +
'{\n' +
' gl_Position = a_position;\n';
frag += '\n' +
'void main()\n' +
'{\n';
// Write matrix.
if (isVertexCase)
op += ' ${PRECISION} vec4 coords = a_coords;\n';
else
op += ' ${PRECISION} vec4 coords = v_coords;\n';
op += ' ${PRECISION} ${MAT_TYPE} tmp;\n';
if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
op += ' tmp[0] = ${VEC_TYPE}(coords);\n';
if (numCols >= 2) op += ' tmp[1] = ${VEC_TYPE}(coords.yzwx) * 0.5;\n';
if (numCols >= 3) op += ' tmp[2] = ${VEC_TYPE}(coords.zwxy) * 0.25;\n';
if (numCols >= 4) op += ' tmp[3] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
op += ' tmp[ui_zero] = ${VEC_TYPE}(coords);\n';
if (numCols >= 2) op += ' tmp[ui_one] = ${VEC_TYPE}(coords.yzwx) * 0.5;\n';
if (numCols >= 3) op += ' tmp[ui_two] = ${VEC_TYPE}(coords.zwxy) * 0.25;\n';
if (numCols >= 4) op += ' tmp[ui_three] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n';
}
else if (writeAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
op += ' for (int i = 0; i < ' + numCols + '; i++)\n';
op += ' {\n';
op += ' tmp[i] = ${VEC_TYPE}(coords);\n';
op += ' coords = coords.yzwx * 0.5;\n';
op += ' }\n';
}
else {
assertMsgOptions(writeAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'writeAccess not supported', false, true);
op += ' for (int i = 0; i < ' + matSizeName + '; i++)\n';
op += ' {\n';
op += ' tmp[i] = ${VEC_TYPE}(coords);\n';
op += ' coords = coords.yzwx * 0.5;\n';
op += ' }\n';
}
// Read matrix.
op += ' ${PRECISION} ${VEC_TYPE} res = ${VEC_TYPE}(0.0);\n';
if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC) {
op += ' res += tmp[0];\n';
if (numCols >= 2) op += ' res += tmp[1];\n';
if (numCols >= 3) op += ' res += tmp[2];\n';
if (numCols >= 4) op += ' res += tmp[3];\n';
}
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC) {
op += ' res += tmp[ui_zero];\n';
if (numCols >= 2) op += ' res += tmp[ui_one];\n';
if (numCols >= 3) op += ' res += tmp[ui_two];\n';
if (numCols >= 4) op += ' res += tmp[ui_three];\n';
}
else if (readAccess === es3fShaderIndexingTests.IndexAccessType.STATIC_LOOP) {
op += ' for (int i = 0; i < ' + numCols + '; i++)\n';
op += ' res += tmp[i];\n';
}
else {
assertMsgOptions(readAccess === es3fShaderIndexingTests.IndexAccessType.DYNAMIC_LOOP, 'readAccess not supported', false, true);
op += ' for (int i = 0; i < ' + matSizeName + '; i++)\n';
op += ' res += tmp[i];\n';
}
vtx += isVertexCase ? op : '';
frag += isVertexCase ? '' : op;
op = '';
if (isVertexCase) {
vtx += ' v_color = vec4(res${PADDING});\n';
frag += ' o_color = v_color;\n';
}
else {
vtx += ' v_coords = a_coords;\n';
frag += ' o_color = vec4(res${PADDING});\n';
}
vtx += '}\n';
frag += '}\n';
// Fill in shader templates.
/** @type {Object} */ var params = {};
params['MAT_TYPE'] = gluShaderUtil.getDataTypeName(varType);
params['VEC_TYPE'] = gluShaderUtil.getDataTypeName(vecType);
params['PRECISION'] = "mediump";
if (numRows === 2)
params['PADDING'] = ', 0.0, 1.0';
else if (numRows === 3)
params['PADDING'] = ', 1.0';
else
params['PADDING'] = '';
/** @type {string} */ var vertexShaderSource = tcuStringTemplate.specialize(vtx, params);
/** @type {string} */ var fragmentShaderSource = tcuStringTemplate.specialize(frag, params);
/** @type {function(glsShaderRenderCase.ShaderEvalContext)} */
var evalFunc = es3fShaderIndexingTests.getMatrixSubscriptEvalFunc(varType);
return new es3fShaderIndexingTests.ShaderIndexingCase(caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource, fragmentShaderSource);
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fShaderIndexingTests.ShaderIndexingTests = function() {
tcuTestCase.DeqpTest.call(this, 'indexing', 'Indexing Tests');
};
es3fShaderIndexingTests.ShaderIndexingTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fShaderIndexingTests.ShaderIndexingTests.prototype.constructor = es3fShaderIndexingTests.ShaderIndexingTests;
es3fShaderIndexingTests.ShaderIndexingTests.prototype.init = function() {
var testGroup = tcuTestCase.runner.testCases;
/** @type {Array<gluShaderProgram.shaderType>} */ var s_shaderTypes = [
gluShaderProgram.shaderType.VERTEX,
gluShaderProgram.shaderType.FRAGMENT
];
/** @type {Array<gluShaderUtil.DataType>} */ var s_floatAndVecTypes = [
gluShaderUtil.DataType.FLOAT,
gluShaderUtil.DataType.FLOAT_VEC2,
gluShaderUtil.DataType.FLOAT_VEC3,
gluShaderUtil.DataType.FLOAT_VEC4
];
/** @type {string} */ var name;
/** @type {string} */ var desc;
/** @type {string} */ var shaderTypeName;
/** @type {boolean} */ var isVertexCase;
/** @type {gluShaderProgram.shaderType} */ var shaderType;
/** @type {string} */ var writeAccessName;
/** @type {string} */ var readAccessName;
// Varying array access cases.
/** @type {tcuTestCase.DeqpTest} */ var varyingGroup = tcuTestCase.newTest('varying_array', 'Varying array access tests.');
testGroup.addChild(varyingGroup);
/** @type {gluShaderUtil.DataType} */ var varType;
for (var typeNdx = 0; typeNdx < s_floatAndVecTypes.length; typeNdx++) {
varType = s_floatAndVecTypes[typeNdx];
for (var vertAccessStr in es3fShaderIndexingTests.IndexAccessType) {
for (var fragAccessStr in es3fShaderIndexingTests.IndexAccessType) {
var vertAccess = es3fShaderIndexingTests.IndexAccessType[vertAccessStr];
var fragAccess = es3fShaderIndexingTests.IndexAccessType[fragAccessStr];
/** @type {string} */ var vertAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(vertAccess);
/** @type {string} */ var fragAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(fragAccess);
name = gluShaderUtil.getDataTypeName(varType) + '_' + vertAccessName + '_write_' + fragAccessName + '_read';
desc = 'Varying array with ' + vertAccessName + ' write in vertex shader and ' + fragAccessName + ' read in fragment shader.';
varyingGroup.addChild(es3fShaderIndexingTests.createVaryingArrayCase(name, desc, varType, vertAccess, fragAccess));
}
}
}
// Uniform array access cases.
/** @type {tcuTestCase.DeqpTest} */ var uniformGroup = tcuTestCase.newTest("uniform_array", "Uniform array access tests.");
testGroup.addChild(uniformGroup);
for (var typeNdx = 0; typeNdx < s_floatAndVecTypes.length; typeNdx++) {
varType = s_floatAndVecTypes[typeNdx];
for (var readAccessStr in es3fShaderIndexingTests.IndexAccessType) {
var readAccess = es3fShaderIndexingTests.IndexAccessType[readAccessStr];
readAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(readAccess);
for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
shaderType = s_shaderTypes[shaderTypeNdx];
shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
name = gluShaderUtil.getDataTypeName(varType) + "_" + readAccessName + "_read_" + shaderTypeName;
desc = "Uniform array with " + readAccessName + " read in " + shaderTypeName + " shader.";
isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;
uniformGroup.addChild(es3fShaderIndexingTests.createUniformArrayCase(name, desc, isVertexCase, varType, readAccess));
}
}
}
// Temporary array access cases.
/** @type {tcuTestCase.DeqpTest} */ var tmpGroup = tcuTestCase.newTest("tmp_array", "Temporary array access tests.");
testGroup.addChild(tmpGroup);
for (var typeNdx = 0; typeNdx < s_floatAndVecTypes.length; typeNdx++) {
varType = s_floatAndVecTypes[typeNdx];
for (var writeAccess in es3fShaderIndexingTests.IndexAccessType) {
for (var readAccess in es3fShaderIndexingTests.IndexAccessType) {
writeAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[writeAccess]);
readAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[readAccess]);
for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
shaderType = s_shaderTypes[shaderTypeNdx];
shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
name = gluShaderUtil.getDataTypeName(varType) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
desc = "Temporary array with " + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
isVertexCase = (shaderType === gluShaderProgram.shaderType.VERTEX);
tmpGroup.addChild(es3fShaderIndexingTests.createTmpArrayCase(name, desc, isVertexCase, varType, es3fShaderIndexingTests.IndexAccessType[writeAccess], es3fShaderIndexingTests.IndexAccessType[readAccess]));
}
}
}
}
// Vector indexing with subscripts.
/** @type {Array<gluShaderUtil.DataType>} */ var s_vectorTypes = [
gluShaderUtil.DataType.FLOAT_VEC2,
gluShaderUtil.DataType.FLOAT_VEC3,
gluShaderUtil.DataType.FLOAT_VEC4
];
for (var typeNdx = 0; typeNdx < s_vectorTypes.length; typeNdx++) {
/** @type {tcuTestCase.DeqpTest} */ var vecGroup = tcuTestCase.newTest("vector_subscript", "Vector subscript indexing.");
testGroup.addChild(vecGroup);
varType = s_vectorTypes[typeNdx];
for (var writeAccess in es3fShaderIndexingTests.VectorAccessType) {
for (var readAccess in es3fShaderIndexingTests.VectorAccessType) {
writeAccessName = es3fShaderIndexingTests.getVectorAccessTypeName(es3fShaderIndexingTests.VectorAccessType[writeAccess]);
readAccessName = es3fShaderIndexingTests.getVectorAccessTypeName(es3fShaderIndexingTests.VectorAccessType[readAccess]);
for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
shaderType = s_shaderTypes[shaderTypeNdx];
shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
name = gluShaderUtil.getDataTypeName(varType) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
desc = "Vector subscript access with " + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;
vecGroup.addChild(es3fShaderIndexingTests.createVectorSubscriptCase(name, desc, isVertexCase, varType, es3fShaderIndexingTests.VectorAccessType[writeAccess], es3fShaderIndexingTests.VectorAccessType[readAccess]));
}
}
}
}
// Matrix indexing with subscripts.
/** @type {Array<tcuTestCase.DeqpTest>} */ var matGroup = [
tcuTestCase.newTest("matrix_subscript", "Matrix subscript indexing."),
tcuTestCase.newTest("matrix_subscript", "Matrix subscript indexing."),
tcuTestCase.newTest("matrix_subscript", "Matrix subscript indexing."),
];
for (var ii = 0; ii < matGroup.length; ++ii) {
testGroup.addChild(matGroup[ii]);
}
/** @type {Array<gluShaderUtil.DataType>} */ var s_matrixTypes = [
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
];
for (var typeNdx = 0; typeNdx < s_matrixTypes.length; typeNdx++) {
varType = s_matrixTypes[typeNdx];
for (var writeAccess in es3fShaderIndexingTests.IndexAccessType) {
for (var readAccess in es3fShaderIndexingTests.IndexAccessType) {
writeAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[writeAccess]);
readAccessName = es3fShaderIndexingTests.getIndexAccessTypeName(es3fShaderIndexingTests.IndexAccessType[readAccess]);
for (var shaderTypeNdx = 0; shaderTypeNdx < s_shaderTypes.length; shaderTypeNdx++) {
shaderType = s_shaderTypes[shaderTypeNdx];
shaderTypeName = gluShaderProgram.getShaderTypeName(shaderType);
name = gluShaderUtil.getDataTypeName(varType) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
desc = "Vector subscript access with " + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
isVertexCase = shaderType === gluShaderProgram.shaderType.VERTEX;
matGroup[typeNdx % matGroup.length].addChild(es3fShaderIndexingTests.createMatrixSubscriptCase(
name, desc, isVertexCase, varType, es3fShaderIndexingTests.IndexAccessType[writeAccess], es3fShaderIndexingTests.IndexAccessType[readAccess]));
}
}
}
}
};
/**
* Run test
* @param {WebGL2RenderingContext} context
*/
es3fShaderIndexingTests.run = function(context, range) {
gl = context;
//Set up Test Root parameters
var state = tcuTestCase.runner;
state.setRoot(new es3fShaderIndexingTests.ShaderIndexingTests());
//Set up name and description of this test series.
setCurrentTestName(state.testCases.fullName());
description(state.testCases.getDescription());
try {
if (range)
state.setRange(range);
//Run test cases
tcuTestCase.runTestCases();
}
catch (err) {
testFailedOptions('Failed to es3fShaderIndexingTests.run tests', false);
tcuTestCase.runner.terminate();
}
};
});