/*------------------------------------------------------------------------- * 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 * * http://www.apache.org/licenses/LICENSE-2.0 * * 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.es3fUniformApiTests'); goog.require('framework.common.tcuSurface'); goog.require('framework.common.tcuTestCase'); goog.require('framework.common.tcuTexture'); goog.require('framework.delibs.debase.deMath'); goog.require('framework.delibs.debase.deRandom'); goog.require('framework.delibs.debase.deString'); goog.require('framework.opengl.gluDrawUtil'); goog.require('framework.opengl.gluShaderProgram'); goog.require('framework.opengl.gluShaderUtil'); goog.require('framework.opengl.gluTexture'); goog.require('framework.opengl.gluVarType'); goog.scope(function() { var es3fUniformApiTests = functional.gles3.es3fUniformApiTests; var gluDrawUtil = framework.opengl.gluDrawUtil; var gluShaderUtil = framework.opengl.gluShaderUtil; var gluShaderProgram = framework.opengl.gluShaderProgram; var gluTexture = framework.opengl.gluTexture; var gluVarType = framework.opengl.gluVarType; var tcuTestCase = framework.common.tcuTestCase; var tcuSurface = framework.common.tcuSurface; var tcuTexture = framework.common.tcuTexture; var deMath = framework.delibs.debase.deMath; var deString = framework.delibs.debase.deString; var deRandom = framework.delibs.debase.deRandom; /** @type {WebGL2RenderingContext} */ var gl; /** @typedef {function(gluShaderUtil.DataType): boolean} */ es3fUniformApiTests.dataTypePredicate; /** @type {number} */ es3fUniformApiTests.MAX_RENDER_WIDTH = 32; /** @type {number} */ es3fUniformApiTests.MAX_RENDER_HEIGHT = 32; /** @type {number} */ es3fUniformApiTests.MAX_NUM_SAMPLER_UNIFORMS = 16; /** @type {Array} */ es3fUniformApiTests.s_testDataTypes = [ gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.FLOAT_VEC2, gluShaderUtil.DataType.FLOAT_VEC3, gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.FLOAT_MAT2, gluShaderUtil.DataType.FLOAT_MAT2X3, gluShaderUtil.DataType.FLOAT_MAT2X4, gluShaderUtil.DataType.FLOAT_MAT3X2, gluShaderUtil.DataType.FLOAT_MAT3, gluShaderUtil.DataType.FLOAT_MAT3X4, gluShaderUtil.DataType.FLOAT_MAT4X2, gluShaderUtil.DataType.FLOAT_MAT4X3, gluShaderUtil.DataType.FLOAT_MAT4, gluShaderUtil.DataType.INT, gluShaderUtil.DataType.INT_VEC2, gluShaderUtil.DataType.INT_VEC3, gluShaderUtil.DataType.INT_VEC4, gluShaderUtil.DataType.UINT, gluShaderUtil.DataType.UINT_VEC2, gluShaderUtil.DataType.UINT_VEC3, gluShaderUtil.DataType.UINT_VEC4, gluShaderUtil.DataType.BOOL, gluShaderUtil.DataType.BOOL_VEC2, gluShaderUtil.DataType.BOOL_VEC3, gluShaderUtil.DataType.BOOL_VEC4, gluShaderUtil.DataType.SAMPLER_2D, gluShaderUtil.DataType.SAMPLER_CUBE // \note We don't test all sampler types here. ]; /** * Returns a substring from the beginning to the last occurence of the * specified character * @param {string} str The string in which to search * @param {string} c A single character * @return {string} */ es3fUniformApiTests.beforeLast = function(str, c) { return str.substring(0, str.lastIndexOf(c)); }; /** * es3fUniformApiTests.fillWithColor * @param {tcuTexture.PixelBufferAccess} access , * @param {Array} color Array of four color components. */ es3fUniformApiTests.fillWithColor = function(access, color) { for (var z = 0; z < access.getDepth(); z++) for (var y = 0; y < access.getHeight(); y++) for (var x = 0; x < access.getWidth(); x++) access.setPixel(color, x, y, z); }; /** * @param {gluShaderUtil.DataType} type * @return {number} */ es3fUniformApiTests.getSamplerNumLookupDimensions = function(type) { switch (type) { case gluShaderUtil.DataType.SAMPLER_2D: case gluShaderUtil.DataType.INT_SAMPLER_2D: case gluShaderUtil.DataType.UINT_SAMPLER_2D: return 2; case gluShaderUtil.DataType.SAMPLER_3D: case gluShaderUtil.DataType.INT_SAMPLER_3D: case gluShaderUtil.DataType.UINT_SAMPLER_3D: case gluShaderUtil.DataType.SAMPLER_2D_SHADOW: case gluShaderUtil.DataType.SAMPLER_2D_ARRAY: case gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY: case gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY: case gluShaderUtil.DataType.SAMPLER_CUBE: case gluShaderUtil.DataType.INT_SAMPLER_CUBE: case gluShaderUtil.DataType.UINT_SAMPLER_CUBE: return 3; case gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW: case gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW: return 4; default: throw new Error('es3fUniformApiTests.getSamplerNumLookupDimensions - Invalid type'); } }; /** * @param {gluShaderUtil.DataType} type * @return {gluShaderUtil.DataType} */ es3fUniformApiTests.getSamplerLookupReturnType = function(type) { switch (type) { case gluShaderUtil.DataType.SAMPLER_2D: case gluShaderUtil.DataType.SAMPLER_CUBE: case gluShaderUtil.DataType.SAMPLER_2D_ARRAY: case gluShaderUtil.DataType.SAMPLER_3D: return gluShaderUtil.DataType.FLOAT_VEC4; case gluShaderUtil.DataType.UINT_SAMPLER_2D: case gluShaderUtil.DataType.UINT_SAMPLER_CUBE: case gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY: case gluShaderUtil.DataType.UINT_SAMPLER_3D: return gluShaderUtil.DataType.UINT_VEC4; case gluShaderUtil.DataType.INT_SAMPLER_2D: case gluShaderUtil.DataType.INT_SAMPLER_CUBE: case gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY: case gluShaderUtil.DataType.INT_SAMPLER_3D: return gluShaderUtil.DataType.INT_VEC4; case gluShaderUtil.DataType.SAMPLER_2D_SHADOW: case gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW: case gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW: return gluShaderUtil.DataType.FLOAT; default: throw new Error('es3fUniformApiTests.getSamplerLookupReturnType - Invalid type'); } }; /** * @param {gluShaderUtil.DataType} T DataType to compare the type. Used to be a template param * @param {gluShaderUtil.DataType} t * @return {boolean} */ es3fUniformApiTests.dataTypeEquals = function(T, t) { return t == T; }; /** * @param {number} N Row number. Used to be a template parameter * @param {gluShaderUtil.DataType} t * @return {boolean} */ es3fUniformApiTests.dataTypeIsMatrixWithNRows = function(N, t) { return gluShaderUtil.isDataTypeMatrix(t) && gluShaderUtil.getDataTypeMatrixNumRows(t) == N; }; /** * @param {gluVarType.VarType} type * @param {es3fUniformApiTests.dataTypePredicate} predicate * @return {boolean} */ es3fUniformApiTests.typeContainsMatchingBasicType = function(type, predicate) { if (type.isBasicType()) return predicate(type.getBasicType()); else if (type.isArrayType()) return es3fUniformApiTests.typeContainsMatchingBasicType(type.getElementType(), predicate); else { assertMsgOptions(type.isStructType(), 'es3fUniformApiTests.typeContainsMatchingBasicType - not a struct type', false, true); /** @type {gluVarType.StructType} */ var structType = type.getStruct(); for (var i = 0; i < structType.getSize(); i++) if (es3fUniformApiTests.typeContainsMatchingBasicType(structType.getMember(i).getType(), predicate)) return true; return false; } }; /** * @param {Array} dst * @param {gluVarType.VarType} type */ es3fUniformApiTests.getDistinctSamplerTypes = function(dst, type) { if (type.isBasicType()) { /** @type {gluShaderUtil.DataType} */ var basicType = type.getBasicType(); if (gluShaderUtil.isDataTypeSampler(basicType) && dst.indexOf(basicType) == -1) dst.push(basicType); } else if (type.isArrayType()) es3fUniformApiTests.getDistinctSamplerTypes(dst, type.getElementType()); else { assertMsgOptions(type.isStructType(), 'es3fUniformApiTests.getDistinctSamplerTypes - not a struct type', false, true); /** @type {gluVarType.StructType} */ var structType = type.getStruct(); for (var i = 0; i < structType.getSize(); i++) es3fUniformApiTests.getDistinctSamplerTypes(dst, structType.getMember(i).getType()); } }; /** * @param {gluVarType.VarType} type * @return {number} */ es3fUniformApiTests.getNumSamplersInType = function(type) { if (type.isBasicType()) return gluShaderUtil.isDataTypeSampler(type.getBasicType()) ? 1 : 0; else if (type.isArrayType()) return es3fUniformApiTests.getNumSamplersInType(type.getElementType()) * type.getArraySize(); else { assertMsgOptions(type.isStructType(), 'es3fUniformApiTests.getNumSamplersInType - not a struct type', false, true); /** @type {gluVarType.StructType} */ var structType = type.getStruct(); /** @type {number} */ var sum = 0; for (var i = 0; i < structType.getSize(); i++) sum += es3fUniformApiTests.getNumSamplersInType(structType.getMember(i).getType()); return sum; } }; /** @typedef { {type: gluVarType.VarType, ndx: number}} */ es3fUniformApiTests.VarTypeWithIndex; /** * @param {number} maxDepth * @param {number} curStructIdx Out parameter, instead returning it in the VarTypeWithIndex structure. * @param {Array} structTypesDst * @param {deRandom.Random} rnd * @return {es3fUniformApiTests.VarTypeWithIndex} */ es3fUniformApiTests.generateRandomType = function(maxDepth, curStructIdx, structTypesDst, rnd) { /** @type {boolean} */ var isStruct = maxDepth > 0 && rnd.getFloat() < 0.2; /** @type {boolean} */ var isArray = rnd.getFloat() < 0.3; if (isStruct) { /** @type {number} */ var numMembers = rnd.getInt(1, 5); /** @type {gluVarType.StructType} */ var structType = gluVarType.newStructType('structType' + curStructIdx++); for (var i = 0; i < numMembers; i++) { /** @type {es3fUniformApiTests.VarTypeWithIndex} */ var typeWithIndex = es3fUniformApiTests.generateRandomType(maxDepth - 1, curStructIdx, structTypesDst, rnd); curStructIdx = typeWithIndex.ndx; structType.addMember('m' + i, typeWithIndex.type); } structTypesDst.push(structType); return (isArray ? { type: gluVarType.newTypeArray(gluVarType.newTypeStruct(structType), rnd.getInt(1, 5)), ndx: curStructIdx } : { type: gluVarType.newTypeStruct(structType), ndx: curStructIdx }); } else { /** @type {gluShaderUtil.DataType} */ var basicType = es3fUniformApiTests.s_testDataTypes[rnd.getInt(0, es3fUniformApiTests.s_testDataTypes.length - 1)]; /** @type {gluShaderUtil.precision} */ var precision; if (!gluShaderUtil.isDataTypeBoolOrBVec(basicType)) precision = gluShaderUtil.precision.PRECISION_MEDIUMP; return (isArray ? { type: gluVarType.newTypeArray(gluVarType.newTypeBasic(basicType, precision), rnd.getInt(1, 5)), ndx: curStructIdx } : { type: gluVarType.newTypeBasic(basicType, precision), ndx: curStructIdx }); } }; /** * es3fUniformApiTests.SamplerV structure * @constructor */ es3fUniformApiTests.SamplerV = function() { this.samplerV = { /** @type {number} */ unit: 0, /** @type {Array} */ fillColor: [] }; }; /** * es3fUniformApiTests.VarValue class. may contain different types. * @constructor */ es3fUniformApiTests.VarValue = function() { /** @type {gluShaderUtil.DataType} */ this.type; /** @type {Array | es3fUniformApiTests.SamplerV} */ this.val = []; }; /** * @enum {number} */ es3fUniformApiTests.CaseShaderType = { VERTEX: 0, FRAGMENT: 1, BOTH: 2 }; /** * es3fUniformApiTests.Uniform struct. * @param {string} name_ * @param {gluVarType.VarType} type_ * @constructor */ es3fUniformApiTests.Uniform = function(name_, type_) { /** @type {string} */ this.name = name_; /** @type {gluVarType.VarType} */ this.type = type_; }; // A set of uniforms, along with related struct types. /** * class es3fUniformApiTests.UniformCollection * @constructor */ es3fUniformApiTests.UniformCollection = function() { /** @type {Array} */ this.m_uniforms = []; /** @type {Array} */ this.m_structTypes = []; }; /** * @return {number} */ es3fUniformApiTests.UniformCollection.prototype.getNumUniforms = function() {return this.m_uniforms.length;}; /** * @return {number} */ es3fUniformApiTests.UniformCollection.prototype.getNumStructTypes = function() {return this.m_structTypes.length;}; /** * @param {number} ndx * @return {es3fUniformApiTests.Uniform} */ es3fUniformApiTests.UniformCollection.prototype.getUniform = function(ndx) {return this.m_uniforms[ndx];}; /** * @param {number} ndx * @return {gluVarType.StructType} */ es3fUniformApiTests.UniformCollection.prototype.getStructType = function(ndx) {return this.m_structTypes[ndx];}; /** * @param {es3fUniformApiTests.Uniform} uniform */ es3fUniformApiTests.UniformCollection.prototype.addUniform = function(uniform) {this.m_uniforms.push(uniform);}; /** * @param {gluVarType.StructType} type */ es3fUniformApiTests.UniformCollection.prototype.addStructType = function(type) {this.m_structTypes.push(type);}; // Add the contents of m_uniforms and m_structTypes to receiver, and remove them from this one. // \note receiver takes ownership of the struct types. /** * @param {es3fUniformApiTests.UniformCollection} receiver */ es3fUniformApiTests.UniformCollection.prototype.moveContents = function(receiver) { for (var i = 0; i < this.m_uniforms.length; i++) receiver.addUniform(this.m_uniforms[i]); this.m_uniforms.length = 0; for (var i = 0; i < this.m_structTypes.length; i++) receiver.addStructType(this.m_structTypes[i]); this.m_structTypes.length = 0; }; /** * @param {es3fUniformApiTests.dataTypePredicate} predicate * @return {boolean} */ es3fUniformApiTests.UniformCollection.prototype.containsMatchingBasicType = function(predicate) { for (var i = 0; i < this.m_uniforms.length; i++) if (es3fUniformApiTests.typeContainsMatchingBasicType(this.m_uniforms[i].type, predicate)) return true; return false; }; /** * @return {Array} */ es3fUniformApiTests.UniformCollection.prototype.getSamplerTypes = function() { /** @type {Array} */ var samplerTypes = []; for (var i = 0; i < this.m_uniforms.length; i++) es3fUniformApiTests.getDistinctSamplerTypes(samplerTypes, this.m_uniforms[i].type); return samplerTypes; }; /** * @return {boolean} */ es3fUniformApiTests.UniformCollection.prototype.containsSeveralSamplerTypes = function() { return this.getSamplerTypes().length > 1; }; /** * @return {number} */ es3fUniformApiTests.UniformCollection.prototype.getNumSamplers = function() { var sum = 0; for (var i = 0; i < this.m_uniforms.length; i++) sum += es3fUniformApiTests.getNumSamplersInType(this.m_uniforms[i].type); return sum; }; /** * @param {gluShaderUtil.DataType} type * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.basic = function(type, nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); /** @type {gluShaderUtil.precision} */ var prec; if (!gluShaderUtil.isDataTypeBoolOrBVec(type)) prec = gluShaderUtil.precision.PRECISION_MEDIUMP; res.m_uniforms.push(new es3fUniformApiTests.Uniform('u_var' + nameSuffix, gluVarType.newTypeBasic(type, prec))); return res; }; /** * @param {gluShaderUtil.DataType} type * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.basicArray = function(type, nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); /** @type {gluShaderUtil.precision} */ var prec; if (!gluShaderUtil.isDataTypeBoolOrBVec(type)) prec = gluShaderUtil.precision.PRECISION_MEDIUMP; res.m_uniforms.push(new es3fUniformApiTests.Uniform('u_var' + nameSuffix, gluVarType.newTypeArray(gluVarType.newTypeBasic(type, prec), 3))); return res; }; /** * @param {gluShaderUtil.DataType} type0 * @param {gluShaderUtil.DataType} type1 * @param {boolean} containsArrays * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.basicStruct = function(type0, type1, containsArrays, nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); /** @type {gluShaderUtil.precision} */ var prec0; if (!gluShaderUtil.isDataTypeBoolOrBVec(type0)) prec0 = gluShaderUtil.precision.PRECISION_MEDIUMP; /** @type {gluShaderUtil.precision} */ var prec1; if (!gluShaderUtil.isDataTypeBoolOrBVec(type1)) prec1 = gluShaderUtil.precision.PRECISION_MEDIUMP; /** @type {gluVarType.StructType} */ var structType = gluVarType.newStructType('structType' + nameSuffix); structType.addMember('m0', gluVarType.newTypeBasic(type0, prec0)); structType.addMember('m1', gluVarType.newTypeBasic(type1, prec1)); if (containsArrays) { structType.addMember('m2', gluVarType.newTypeArray(gluVarType.newTypeBasic(type0, prec0), 3)); structType.addMember('m3', gluVarType.newTypeArray(gluVarType.newTypeBasic(type1, prec1), 3)); } res.addStructType(structType); res.addUniform(new es3fUniformApiTests.Uniform('u_var' + nameSuffix, gluVarType.newTypeStruct(structType))); return res; }; /** * @param {gluShaderUtil.DataType} type0 * @param {gluShaderUtil.DataType} type1 * @param {boolean} containsArrays * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.structInArray = function(type0, type1, containsArrays, nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {es3fUniformApiTests.UniformCollection} */ var res = es3fUniformApiTests.UniformCollection.basicStruct(type0, type1, containsArrays, nameSuffix); res.getUniform(0).type = gluVarType.newTypeArray(res.getUniform(0).type, 3); return res; }; /** * @param {gluShaderUtil.DataType} type0 * @param {gluShaderUtil.DataType} type1 * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.nestedArraysStructs = function(type0, type1, nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); /** @type {gluShaderUtil.precision} */ var prec0; if (!gluShaderUtil.isDataTypeBoolOrBVec(type0)) prec0 = gluShaderUtil.precision.PRECISION_MEDIUMP; /** @type {gluShaderUtil.precision} */ var prec1; if (!gluShaderUtil.isDataTypeBoolOrBVec(type1)) prec1 = gluShaderUtil.precision.PRECISION_MEDIUMP; /** @type {gluVarType.StructType} */ var structType = gluVarType.newStructType('structType' + nameSuffix); /** @type {gluVarType.StructType} */ var subStructType = gluVarType.newStructType('subStructType' + nameSuffix); /** @type {gluVarType.StructType} */ var subSubStructType = gluVarType.newStructType('subSubStructType' + nameSuffix); subSubStructType.addMember('mss0', gluVarType.newTypeBasic(type0, prec0)); subSubStructType.addMember('mss1', gluVarType.newTypeBasic(type1, prec1)); subStructType.addMember('ms0', gluVarType.newTypeBasic(type1, prec1)); subStructType.addMember('ms1', gluVarType.newTypeArray(gluVarType.newTypeBasic(type0, prec0), 2)); subStructType.addMember('ms2', gluVarType.newTypeArray(gluVarType.newTypeStruct(subSubStructType), 2)); structType.addMember('m0', gluVarType.newTypeBasic(type0, prec0)); structType.addMember('m1', gluVarType.newTypeStruct(subStructType)); structType.addMember('m2', gluVarType.newTypeBasic(type1, prec1)); res.addStructType(subSubStructType); res.addStructType(subStructType); res.addStructType(structType); res.addUniform(new es3fUniformApiTests.Uniform('u_var' + nameSuffix, gluVarType.newTypeStruct(structType))); return res; }; /** * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.multipleBasic = function(nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {Array} */ var types = [gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.INT_VEC3, gluShaderUtil.DataType.UINT_VEC4, gluShaderUtil.DataType.FLOAT_MAT3, gluShaderUtil.DataType.BOOL_VEC2]; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); for (var i = 0; i < types.length; i++) { /** @type {es3fUniformApiTests.UniformCollection} */ var sub = es3fUniformApiTests.UniformCollection.basic(types[i], '_' + i + nameSuffix); sub.moveContents(res); } return res; }; /** * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.multipleBasicArray = function(nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {Array} */ var types = [gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.INT_VEC3, gluShaderUtil.DataType.BOOL_VEC2]; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); for (var i = 0; i < types.length; i++) { /** @type {es3fUniformApiTests.UniformCollection} */ var sub = es3fUniformApiTests.UniformCollection.basicArray(types[i], '_' + i + nameSuffix); sub.moveContents(res); } return res; }; /** * @param {string=} nameSuffix * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.multipleNestedArraysStructs = function(nameSuffix) { if (nameSuffix === undefined) nameSuffix = ''; /** @type {Array} */ var types0 = [gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.INT, gluShaderUtil.DataType.BOOL_VEC4]; /** @type {Array} */ var types1 = [gluShaderUtil.DataType.FLOAT_VEC4, gluShaderUtil.DataType.INT_VEC4, gluShaderUtil.DataType.BOOL]; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); assertMsgOptions(types0.length == types1.length, 'es3fUniformApiTests.UniformCollection.multipleNestedArraysStructs - lengths are not the same', false, true); for (var i = 0; i < types0.length; i++) { /** @type {es3fUniformApiTests.UniformCollection} */ var sub = es3fUniformApiTests.UniformCollection.nestedArraysStructs(types0[i], types1[i], '_' + i + nameSuffix); sub.moveContents(res); } return res; }; /** * @param {number} seed * @return {es3fUniformApiTests.UniformCollection} */ es3fUniformApiTests.UniformCollection.random = function(seed) { /** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed); /** @type {number} */ var numUniforms = rnd.getInt(1, 5); /** @type {number} */ var structIdx = 0; /** @type {es3fUniformApiTests.UniformCollection} */ var res = new es3fUniformApiTests.UniformCollection(); for (var i = 0; i < numUniforms; i++) { /** @type {Array} */ var structTypes = []; /** @type {es3fUniformApiTests.Uniform} */ var uniform = new es3fUniformApiTests.Uniform('u_var' + i, new gluVarType.VarType()); // \note Discard uniforms that would cause number of samplers to exceed es3fUniformApiTests.MAX_NUM_SAMPLER_UNIFORMS. do { var temp = es3fUniformApiTests.generateRandomType(3, structIdx, structTypes, rnd); structIdx = temp.ndx; uniform.type = temp.type; } while (res.getNumSamplers() + es3fUniformApiTests.getNumSamplersInType(uniform.type) > es3fUniformApiTests.MAX_NUM_SAMPLER_UNIFORMS); res.addUniform(uniform); for (var j = 0; j < structTypes.length; j++) res.addStructType(structTypes[j]); } return res; }; /** * @param {es3fUniformApiTests.VarValue} sampler * @return {es3fUniformApiTests.VarValue} */ es3fUniformApiTests.getSamplerFillValue = function(sampler) { assertMsgOptions(gluShaderUtil.isDataTypeSampler(sampler.type), 'es3fUniformApiTests.getSamplerFillValue - not a sampler type', false, true); /** @type {es3fUniformApiTests.VarValue} */ var result = new es3fUniformApiTests.VarValue(); result.type = es3fUniformApiTests.getSamplerLookupReturnType(sampler.type); switch (result.type) { case gluShaderUtil.DataType.FLOAT_VEC4: for (var i = 0; i < 4; i++) result.val[i] = sampler.val.samplerV.fillColor[i]; break; case gluShaderUtil.DataType.UINT_VEC4: for (var i = 0; i < 4; i++) result.val[i] = sampler.val.samplerV.fillColor[i]; break; case gluShaderUtil.DataType.INT_VEC4: for (var i = 0; i < 4; i++) result.val[i] = sampler.val.samplerV.fillColor[i]; break; case gluShaderUtil.DataType.FLOAT: result.val[0] = sampler.val.samplerV.fillColor[0]; break; default: throw new Error('es3fUniformApiTests.getSamplerFillValue - Invalid type'); } return result; }; /** * @param {es3fUniformApiTests.VarValue} sampler * @return {es3fUniformApiTests.VarValue} */ es3fUniformApiTests.getSamplerUnitValue = function(sampler) { assertMsgOptions(gluShaderUtil.isDataTypeSampler(sampler.type), 'es3fUniformApiTests.getSamplerUnitValue - not a sampler type', false, true); /** @type {es3fUniformApiTests.VarValue} */ var result = new es3fUniformApiTests.VarValue(); result.type = gluShaderUtil.DataType.INT; result.val[0] = sampler.val.samplerV.unit; return result; }; /** * @param {gluShaderUtil.DataType} original * @return {gluShaderUtil.DataType} */ es3fUniformApiTests.getDataTypeTransposedMatrix = function(original) { return gluShaderUtil.getDataTypeMatrix(gluShaderUtil.getDataTypeMatrixNumRows(original), gluShaderUtil.getDataTypeMatrixNumColumns(original)); }; /** * @param {es3fUniformApiTests.VarValue} original * @return {es3fUniformApiTests.VarValue} */ es3fUniformApiTests.getTransposeMatrix = function(original) { assertMsgOptions(gluShaderUtil.isDataTypeMatrix(original.type), 'es3fUniformApiTests.getTransposeMatrix - not a matrix', false, true); /** @type {number} */ var rows = gluShaderUtil.getDataTypeMatrixNumRows(original.type); /** @type {number} */ var cols = gluShaderUtil.getDataTypeMatrixNumColumns(original.type); /** @type {es3fUniformApiTests.VarValue} */ var result = new es3fUniformApiTests.VarValue(); result.type = es3fUniformApiTests.getDataTypeTransposedMatrix(original.type); for (var i = 0; i < rows; i++) for (var j = 0; j < cols; j++) result.val[i * cols + j] = original.val[j * rows + i]; return result; }; /** * @param {es3fUniformApiTests.VarValue} value * @return {string} */ es3fUniformApiTests.shaderVarValueStr = function(value) { /** @type {number} */ var numElems = gluShaderUtil.getDataTypeScalarSize(value.type); /** @type {string} */ var result = ''; if (numElems > 1) result += gluShaderUtil.getDataTypeName(value.type) + '('; for (var i = 0; i < numElems; i++) { if (i > 0) result += ', '; if (gluShaderUtil.isDataTypeFloatOrVec(value.type) || gluShaderUtil.isDataTypeMatrix(value.type)) result += value.val[i].toFixed(2); else if (gluShaderUtil.isDataTypeIntOrIVec((value.type))) result += value.val[i]; else if (gluShaderUtil.isDataTypeUintOrUVec((value.type))) result += value.val[i] + 'u'; else if (gluShaderUtil.isDataTypeBoolOrBVec((value.type))) result += value.val[i] ? 'true' : 'false'; else if (gluShaderUtil.isDataTypeSampler((value.type))) result += es3fUniformApiTests.shaderVarValueStr(es3fUniformApiTests.getSamplerFillValue(value)); else throw new Error('es3fUniformApiTests.shaderVarValueStr - invalid type'); } if (numElems > 1) result += ')'; return result; }; /** * @param {es3fUniformApiTests.VarValue} value * @return {string} */ es3fUniformApiTests.apiVarValueStr = function(value) { /** @type {number} */ var numElems = gluShaderUtil.getDataTypeScalarSize(value.type); /** @type {string} */ var result = ''; if (numElems > 1) result += '('; for (var i = 0; i < numElems; i++) { if (i > 0) result += ', '; if (gluShaderUtil.isDataTypeFloatOrVec(value.type) || gluShaderUtil.isDataTypeMatrix(value.type)) result += value.val[i].toFixed(2); else if (gluShaderUtil.isDataTypeIntOrIVec(value.type) || gluShaderUtil.isDataTypeUintOrUVec(value.type)) result += value.val[i]; else if (gluShaderUtil.isDataTypeBoolOrBVec(value.type)) result += value.val[i] ? 'true' : 'false'; else if (gluShaderUtil.isDataTypeSampler(value.type)) result += value.val.samplerV.unit; else throw new Error('es3fUniformApiTests.apiVarValueStr - Invalid type'); } if (numElems > 1) result += ')'; return result; }; // samplerUnit used if type is a sampler type. \note Samplers' unit numbers are not randomized. /** * @param {gluShaderUtil.DataType} type * @param {deRandom.Random} rnd * @param {number=} samplerUnit * @return {es3fUniformApiTests.VarValue} */ es3fUniformApiTests.generateRandomVarValue = function(type, rnd, samplerUnit) { if (samplerUnit === undefined) samplerUnit = -1; /** @type {number} */ var numElems = gluShaderUtil.getDataTypeScalarSize(type); /** @type {es3fUniformApiTests.VarValue} */ var result = new es3fUniformApiTests.VarValue(); result.type = type; assertMsgOptions( (samplerUnit >= 0) == (gluShaderUtil.isDataTypeSampler(type)), 'es3fUniformApiTests.generateRandomVarValue - sampler units do not match type', false, true ); if (gluShaderUtil.isDataTypeFloatOrVec(type) || gluShaderUtil.isDataTypeMatrix(type)) { for (var i = 0; i < numElems; i++) result.val[i] = rnd.getFloat(-10.0, 10.0); } else if (gluShaderUtil.isDataTypeIntOrIVec(type)) { for (var i = 0; i < numElems; i++) result.val[i] = rnd.getInt(-10, 10); } else if (gluShaderUtil.isDataTypeUintOrUVec(type)) { for (var i = 0; i < numElems; i++) result.val[i] = rnd.getInt(0, 10); } else if (gluShaderUtil.isDataTypeBoolOrBVec(type)) { for (var i = 0; i < numElems; i++) result.val[i] = rnd.getBool(); } else if (gluShaderUtil.isDataTypeSampler(type)) { /** @type {gluShaderUtil.DataType} */ var texResultType = es3fUniformApiTests.getSamplerLookupReturnType(type); /** @type {gluShaderUtil.DataType} */ var texResultScalarType = gluShaderUtil.getDataTypeScalarTypeAsDataType(texResultType); /** @type {number} */ var texResultNumDims = gluShaderUtil.getDataTypeScalarSize(texResultType); result.val = new es3fUniformApiTests.SamplerV(); result.val.samplerV.unit = samplerUnit; for (var i = 0; i < texResultNumDims; i++) { switch (texResultScalarType) { case gluShaderUtil.DataType.FLOAT: result.val.samplerV.fillColor[i] = rnd.getFloat(0.0, 1.0); break; case gluShaderUtil.DataType.INT: result.val.samplerV.fillColor[i] = rnd.getInt(-10, 10); break; case gluShaderUtil.DataType.UINT: result.val.samplerV.fillColor[i] = rnd.getInt(0, 10); break; default: throw new Error('es3fUniformApiTests.generateRandomVarValue - Invalid scalar type'); } } } else throw new Error('es3fUniformApiTests.generateRandomVarValue - Invalid type'); return result; }; /** * @param {gluShaderUtil.DataType} type * @return {es3fUniformApiTests.VarValue} */ es3fUniformApiTests.generateZeroVarValue = function(type) { /** @type {number} */ var numElems = gluShaderUtil.getDataTypeScalarSize(type); /** @type {es3fUniformApiTests.VarValue} */ var result = new es3fUniformApiTests.VarValue(); result.type = type; if (gluShaderUtil.isDataTypeFloatOrVec(type) || gluShaderUtil.isDataTypeMatrix(type)) { for (var i = 0; i < numElems; i++) result.val[i] = 0.0; } else if (gluShaderUtil.isDataTypeIntOrIVec(type)) { for (var i = 0; i < numElems; i++) result.val[i] = 0; } else if (gluShaderUtil.isDataTypeUintOrUVec(type)) { for (var i = 0; i < numElems; i++) result.val[i] = 0; } else if (gluShaderUtil.isDataTypeBoolOrBVec(type)) { for (var i = 0; i < numElems; i++) result.val[i] = false; } else if (gluShaderUtil.isDataTypeSampler(type)) { /** @type {gluShaderUtil.DataType} */ var texResultType = es3fUniformApiTests.getSamplerLookupReturnType(type); /** @type {gluShaderUtil.DataType} */ var texResultScalarType = gluShaderUtil.getDataTypeScalarTypeAsDataType(texResultType); /** @type {number} */ var texResultNumDims = gluShaderUtil.getDataTypeScalarSize(texResultType); result.val = new es3fUniformApiTests.SamplerV(); result.val.samplerV.unit = 0; for (var i = 0; i < texResultNumDims; i++) { switch (texResultScalarType) { case gluShaderUtil.DataType.FLOAT: result.val.samplerV.fillColor[i] = 0.12 * i; break; case gluShaderUtil.DataType.INT: result.val.samplerV.fillColor[i] = -2 + i; break; case gluShaderUtil.DataType.UINT: result.val.samplerV.fillColor[i] = 4 + i; break; default: throw new Error('es3fUniformApiTests.generateZeroVarValue - Invalid scalar type'); } } } else throw new Error('es3fUniformApiTests.generateZeroVarValue - Invalid type'); return result; }; /** * @param {es3fUniformApiTests.VarValue} a * @param {es3fUniformApiTests.VarValue} b * @return {boolean} */ es3fUniformApiTests.apiVarValueEquals = function(a, b) { /** @type {number} */ var size = gluShaderUtil.getDataTypeScalarSize(a.type); /** @type {number} */ var floatThreshold = 0.05; assertMsgOptions(a.type == b.type, 'es3fUniformApiTests.apiVarValueEquals - types are different', false, true); if (gluShaderUtil.isDataTypeFloatOrVec(a.type) || gluShaderUtil.isDataTypeMatrix(a.type)) { for (var i = 0; i < size; i++) if (Math.abs(a.val[i] - b.val[i]) >= floatThreshold) return false; } else if (gluShaderUtil.isDataTypeIntOrIVec(a.type)) { for (var i = 0; i < size; i++) if (a.val[i] != b.val[i]) return false; } else if (gluShaderUtil.isDataTypeUintOrUVec(a.type)) { for (var i = 0; i < size; i++) if (a.val[i] != b.val[i]) return false; } else if (gluShaderUtil.isDataTypeBoolOrBVec(a.type)) { for (var i = 0; i < size; i++) if (a.val[i] != b.val[i]) return false; } else if (gluShaderUtil.isDataTypeSampler(a.type)) { if (a.val.samplerV.unit != b.val.samplerV.unit) return false; } else throw new Error('es3fUniformApiTests.apiVarValueEquals - Invalid type'); return true; }; /** * @param {es3fUniformApiTests.VarValue} boolValue * @param {gluShaderUtil.DataType} targetScalarType * @param {deRandom.Random} rnd * @return {es3fUniformApiTests.VarValue} */ es3fUniformApiTests.getRandomBoolRepresentation = function(boolValue, targetScalarType, rnd) { assertMsgOptions( gluShaderUtil.isDataTypeBoolOrBVec(boolValue.type), 'es3fUniformApiTests.getRandomBoolRepresentation - Data type not boolean or boolean vector', false, true ); /** @type {number} */ var size = gluShaderUtil.getDataTypeScalarSize(boolValue.type); /** @type {gluShaderUtil.DataType} */ var targetType = size == 1 ? targetScalarType : gluShaderUtil.getDataTypeVector(targetScalarType, size); /** @type {es3fUniformApiTests.VarValue} */ var result = new es3fUniformApiTests.VarValue(); result.type = targetType; switch (targetScalarType) { case gluShaderUtil.DataType.INT: for (var i = 0; i < size; i++) { if (boolValue.val[i]) { result.val[i] = rnd.getInt(-10, 10); if (result.val[i] == 0) result.val[i] = 1; } else result.val[i] = 0; } break; case gluShaderUtil.DataType.UINT: for (var i = 0; i < size; i++) { if (boolValue.val[i]) result.val[i] = rnd.getInt(1, 10); else result.val[i] = 0; } break; case gluShaderUtil.DataType.FLOAT: for (var i = 0; i < size; i++) { if (boolValue.val[i]) { result.val[i] = rnd.getFloat(-10.0, 10.0); if (result.val[i] == 0.0) result.val[i] = 1.0; } else result.val[i] = 0; } break; default: throw new Error('es3fUniformApiTests.getRandomBoolRepresentation - Invalid type'); } return result; }; /** * @param {es3fUniformApiTests.CaseShaderType} type * @return {?string} */ es3fUniformApiTests.getCaseShaderTypeName = function(type) { switch (type) { case es3fUniformApiTests.CaseShaderType.VERTEX: return 'vertex'; case es3fUniformApiTests.CaseShaderType.FRAGMENT: return 'fragment'; case es3fUniformApiTests.CaseShaderType.BOTH: return 'both'; default: throw new Error('es3fUniformApiTests.getCaseShaderTypeName - Invalid shader type'); } }; /** * @param {number} seed * @return {number} */ es3fUniformApiTests.randomCaseShaderType = function(seed) { return (new deRandom.Random(seed)).getInt(0, Object.keys(es3fUniformApiTests.CaseShaderType).length - 1); }; //es3fUniformApiTests.UniformCase definitions /** * es3fUniformApiTests.Feature - Implemented as a function to create an object without unwanted properties. * @constructor */ es3fUniformApiTests.Feature = function() { // ARRAYUSAGE_ONLY_MIDDLE_INDEX: only middle index of each array is used in shader. If not given, use all indices. this.ARRAYUSAGE_ONLY_MIDDLE_INDEX = false; // UNIFORMFUNC_VALUE: use pass-by-value versions of uniform assignment funcs, e.g. glUniform1f(), where possible. If not given, use pass-by-pointer versions. this.UNIFORMFUNC_VALUE = false; // MATRIXMODE_ROWMAJOR: pass matrices to GL in row major form. If not given, use column major. this.MATRIXMODE_ROWMAJOR = false; // ARRAYASSIGN: how basic-type arrays are assigned with glUniform*(). If none given, assign each element of an array separately. this.ARRAYASSIGN_FULL = false; //!< Assign all elements of an array with one glUniform*(). this.ARRAYASSIGN_BLOCKS_OF_TWO = false; //!< Assign two elements per one glUniform*(). // UNIFORMUSAGE_EVERY_OTHER: use about half of the uniforms. If not given, use all uniforms (except that some array indices may be omitted according to ARRAYUSAGE). this.UNIFORMUSAGE_EVERY_OTHER = false; // BOOLEANAPITYPE: type used to pass booleans to and from GL api. If none given, use float. this.BOOLEANAPITYPE_INT = false; this.BOOLEANAPITYPE_UINT = false; // UNIFORMVALUE_ZERO: use zero-valued uniforms. If not given, use random uniform values. this.UNIFORMVALUE_ZERO = false; // ARRAY_FIRST_ELEM_NAME_NO_INDEX: in certain API functions, when referring to the first element of an array, use just the array name without [0] at the end. this.ARRAY_FIRST_ELEM_NAME_NO_INDEX = false; }; // A basic uniform is a uniform (possibly struct or array member) whose type is a basic type (e.g. float, ivec4, sampler2d). /** * @constructor * @param {string} name_ * @param {gluShaderUtil.DataType} type_ * @param {boolean} isUsedInShader_ * @param {es3fUniformApiTests.VarValue} finalValue_ * @param {string=} rootName_ * @param {number=} elemNdx_ * @param {number=} rootSize_ */ es3fUniformApiTests.BasicUniform = function(name_, type_, isUsedInShader_, finalValue_, rootName_, elemNdx_, rootSize_) { /** @type {string} */ this.name = name_; /** @type {gluShaderUtil.DataType} */ this.type = type_; /** @type {boolean} */ this.isUsedInShader = isUsedInShader_; /** @type {es3fUniformApiTests.VarValue} */ this.finalValue = finalValue_; //!< The value we ultimately want to set for this uniform. /** @type {string} */ this.rootName = rootName_ === undefined ? name_ : rootName_; //!< If this is a member of a basic-typed array, rootName is the name of that array with "[0]" appended. Otherwise it equals name. /** @type {number} */ this.elemNdx = elemNdx_ === undefined ? -1 : elemNdx_; //!< If this is a member of a basic-typed array, elemNdx is the index in that array. Otherwise -1. /** @type {number} */ this.rootSize = rootSize_ === undefined ? 1 : rootSize_; //!< If this is a member of a basic-typed array, rootSize is the size of that array. Otherwise 1. }; /** * @param {Array} vec * @param {string} name * @return {es3fUniformApiTests.BasicUniform} */ es3fUniformApiTests.BasicUniform.findWithName = function(vec, name) { for (var i = 0; i < vec.length; i++) { if (vec[i].name == name) return vec[i]; } return null; }; // Reference values for info that is expected to be reported by glGetActiveUniform() or glGetActiveUniforms(). /** * @constructor * @param {string} name_ * @param {gluShaderUtil.DataType} type_ * @param {boolean} used */ es3fUniformApiTests.BasicUniformReportRef = function(name_, type_, used) { /** @type {string} */ this.name = name_; // \note minSize and maxSize are for arrays and can be distinct since implementations are allowed, but not required, to trim the inactive end indices of arrays. /** @type {number} */ this.minSize = 1; /** @type {number} */ this.maxSize = 1; /** @type {gluShaderUtil.DataType} */ this.type = type_; /** @type {boolean} */ this.isUsedInShader = used; }; /** * To be used after constructor * @param {number} minS * @param {number} maxS * @return {es3fUniformApiTests.BasicUniformReportRef} */ es3fUniformApiTests.BasicUniformReportRef.prototype.constructor_A = function(minS, maxS) { this.minSize = minS; this.maxSize = maxS; assertMsgOptions( this.minSize <= this.maxSize, 'es3fUniformApiTests.BasicUniformReportRef.prototype.constructor_A - min size not smaller or equal than max size', false, true ); return this; }; // Info that is actually reported by glGetActiveUniform() or glGetActiveUniforms(). /** * @constructor * @param {string} name_ * @param {number} nameLength_ * @param {number} size_ * @param {gluShaderUtil.DataType} type_ * @param {number} index_ */ es3fUniformApiTests.BasicUniformReportGL = function(name_, nameLength_, size_, type_, index_) { this.name = name_; this.nameLength = nameLength_; this.size = size_; this.type = type_; this.index = index_; }; /** * @param {Array} vec * @param {string} name * @return {es3fUniformApiTests.BasicUniformReportGL} */ es3fUniformApiTests.BasicUniformReportGL.findWithName = function(vec, name) { for (var i = 0; i < vec.length; i++) { if (vec[i].name == name) return vec[i]; } return null; }; /** * es3fUniformApiTests.UniformCase class, inherits from TestCase class * @constructor * @param {string} name * @param {string} description * @extends {tcuTestCase.DeqpTest} */ es3fUniformApiTests.UniformCase = function(name, description) { // \note Randomizes caseType, uniformCollection and features. tcuTestCase.DeqpTest.call(this, name, description); /** @type {es3fUniformApiTests.Feature} */ this.m_features; /** @type {es3fUniformApiTests.UniformCollection} (SharedPtr) */ this.m_uniformCollection; /** @type {number} */ this.m_caseShaderType = 0; /** @type {Array} */ this.m_textures2d = []; /** @type {Array} */ this.m_texturesCube = []; /** @type {Array} */ this.m_filledTextureUnits = []; }; es3fUniformApiTests.UniformCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); /** es3fUniformApiTests.UniformCase prototype restore */ es3fUniformApiTests.UniformCase.prototype.constructor = es3fUniformApiTests.UniformCase; /** * es3fUniformApiTests.UniformCase newC. Creates a es3fUniformApiTests.UniformCase. Use after constructor. * @param {number} seed * @return {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformCase.prototype.newC = function(seed) { this.m_features = this.randomFeatures(seed); this.m_uniformCollection = es3fUniformApiTests.UniformCollection.random(seed); this.m_caseShaderType = es3fUniformApiTests.randomCaseShaderType(seed); return this; }; /** * es3fUniformApiTests.UniformCase new_B (static). Creates a es3fUniformApiTests.UniformCase * @param {string} name * @param {string} description * @param {number} seed * @return {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformCase.new_C = function(name, description, seed) { var uniformCase = new es3fUniformApiTests.UniformCase(name, description).newC(seed); return uniformCase; }; /** * es3fUniformApiTests.UniformCase new_B. Creates a es3fUniformApiTests.UniformCase. Use after constructor. * @param {es3fUniformApiTests.CaseShaderType} caseShaderType * @param {es3fUniformApiTests.UniformCollection} uniformCollection (SharedPtr) * @param {es3fUniformApiTests.Feature} features * @return {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformCase.prototype.newB = function(caseShaderType, uniformCollection, features) { this.m_caseShaderType = caseShaderType; this.m_uniformCollection = uniformCollection; this.m_features = features; return this; }; /** * es3fUniformApiTests.UniformCase new_B (static). Creates a es3fUniformApiTests.UniformCase * @param {string} name * @param {string} description * @param {es3fUniformApiTests.CaseShaderType} caseShaderType * @param {es3fUniformApiTests.UniformCollection} uniformCollection (SharedPtr) * @param {es3fUniformApiTests.Feature} features * @return {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformCase.new_B = function(name, description, caseShaderType, uniformCollection, features) { var uniformCase = new es3fUniformApiTests.UniformCase(name, description).newB(caseShaderType, uniformCollection, features); return uniformCase; }; /** * es3fUniformApiTests.UniformCase new_A. Creates a es3fUniformApiTests.UniformCase. Use after constructor. * @param {es3fUniformApiTests.CaseShaderType} caseShaderType * @param {es3fUniformApiTests.UniformCollection} uniformCollection (SharedPtr) * @return {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformCase.prototype.newA = function(caseShaderType, uniformCollection) { this.m_caseShaderType = caseShaderType; this.m_uniformCollection = uniformCollection; this.m_features = null; return this; }; /** * es3fUniformApiTests.UniformCase new_A (static). Creates a es3fUniformApiTests.UniformCase * @param {string} name * @param {string} description * @param {es3fUniformApiTests.CaseShaderType} caseShaderType * @param {es3fUniformApiTests.UniformCollection} uniformCollection (SharedPtr) * @return {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformCase.new_A = function(name, description, caseShaderType, uniformCollection) { var uniformCase = new es3fUniformApiTests.UniformCase(name, description).newA(caseShaderType, uniformCollection); return uniformCase; }; /** * @param {number} seed * @return {es3fUniformApiTests.Feature} */ es3fUniformApiTests.UniformCase.prototype.randomFeatures = function(seed) { /** @type {es3fUniformApiTests.Feature} */ var result = new es3fUniformApiTests.Feature(); /** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed); result.ARRAYUSAGE_ONLY_MIDDLE_INDEX = rnd.getBool(); result.UNIFORMFUNC_VALUE = rnd.getBool(); result.MATRIXMODE_ROWMAJOR = rnd.getBool(); result.ARRAYASSIGN_FULL = rnd.getBool(); result.ARRAYASSIGN_BLOCKS_OF_TWO = !result.ARRAYASSIGN_FULL; result.UNIFORMUSAGE_EVERY_OTHER = rnd.getBool(); result.BOOLEANAPITYPE_INT = rnd.getBool(); result.BOOLEANAPITYPE_UINT = !result.BOOLEANAPITYPE_INT; result.UNIFORMVALUE_ZERO = rnd.getBool(); return result; }; /** * Initialize the es3fUniformApiTests.UniformCase */ es3fUniformApiTests.UniformCase.prototype.init = function() { /** @type {number} */ var numSamplerUniforms = this.m_uniformCollection.getNumSamplers(); /** @type {number} */ var vertexTexUnitsRequired = this.m_caseShaderType != es3fUniformApiTests.CaseShaderType.FRAGMENT ? numSamplerUniforms : 0; /** @type {number} */ var fragmentTexUnitsRequired = this.m_caseShaderType != es3fUniformApiTests.CaseShaderType.VERTEX ? numSamplerUniforms : 0; /** @type {number} */ var combinedTexUnitsRequired = vertexTexUnitsRequired + fragmentTexUnitsRequired; var vertexTexUnitsSupported = /** @type {number} */ (gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS)); var fragmentTexUnitsSupported = /** @type {number} */ (gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS)); var combinedTexUnitsSupported = /** @type {number} */ (gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS)); assertMsgOptions( numSamplerUniforms <= es3fUniformApiTests.MAX_NUM_SAMPLER_UNIFORMS, 'es3fUniformApiTests.UniformCase.prototype.init - sampler uniforms exceed MAX_NUM_SAMPLER_UNIFORMS', false, true ); if (vertexTexUnitsRequired > vertexTexUnitsSupported) testFailedOptions('' + vertexTexUnitsRequired + ' vertex texture units required, ' + vertexTexUnitsSupported + ' supported', true); if (fragmentTexUnitsRequired > fragmentTexUnitsSupported) testFailedOptions('' + fragmentTexUnitsRequired + ' fragment texture units required, ' + fragmentTexUnitsSupported + ' supported', true); if (combinedTexUnitsRequired > combinedTexUnitsSupported) testFailedOptions('' + combinedTexUnitsRequired + ' combined texture units required, ' + combinedTexUnitsSupported + ' supported', true); }; /** * @param {Array} basicUniformsDst * @param {Array} basicUniformReportsDst * @param {gluVarType.VarType} varType * @param {string} varName * @param {boolean} isParentActive * @param {number} samplerUnitCounter * @param {deRandom.Random} rnd * @return {number} Used to be output parameter. Sampler unit count */ es3fUniformApiTests.UniformCase.prototype.generateBasicUniforms = function(basicUniformsDst, basicUniformReportsDst, varType, varName, isParentActive, samplerUnitCounter, rnd) { /** @type {es3fUniformApiTests.VarValue} */ var value; if (varType.isBasicType()) { /** @type {boolean} */ var isActive = isParentActive && (this.m_features.UNIFORMUSAGE_EVERY_OTHER ? basicUniformsDst.length % 2 == 0 : true); /** @type {gluShaderUtil.DataType} */ var type = varType.getBasicType(); value = this.m_features.UNIFORMVALUE_ZERO ? es3fUniformApiTests.generateZeroVarValue(type) : gluShaderUtil.isDataTypeSampler(type) ? es3fUniformApiTests.generateRandomVarValue(type, rnd, samplerUnitCounter++) : es3fUniformApiTests.generateRandomVarValue(varType.getBasicType(), rnd); basicUniformsDst.push(new es3fUniformApiTests.BasicUniform(varName, varType.getBasicType(), isActive, value)); basicUniformReportsDst.push(new es3fUniformApiTests.BasicUniformReportRef(varName, varType.getBasicType(), isActive)); } else if (varType.isArrayType()) { /** @type {number} */ var size = varType.getArraySize(); /** @type {string} */ var arrayRootName = '' + varName + '[0]'; /** @type {Array} */ var isElemActive = []; for (var elemNdx = 0; elemNdx < varType.getArraySize(); elemNdx++) { /** @type {string} */ var indexedName = '' + varName + '[' + elemNdx + ']'; /** @type {boolean} */ var isCurElemActive = isParentActive && (this.m_features.UNIFORMUSAGE_EVERY_OTHER ? basicUniformsDst.length % 2 == 0 : true) && (this.m_features.ARRAYUSAGE_ONLY_MIDDLE_INDEX ? elemNdx == Math.floor(size / 2) : true); isElemActive.push(isCurElemActive); if (varType.getElementType().isBasicType()) { // \note We don't want separate entries in basicUniformReportsDst for elements of basic-type arrays. /** @type {gluShaderUtil.DataType} */ var elemBasicType = varType.getElementType().getBasicType(); value = this.m_features.UNIFORMVALUE_ZERO ? es3fUniformApiTests.generateZeroVarValue(elemBasicType) : gluShaderUtil.isDataTypeSampler(elemBasicType) ? es3fUniformApiTests.generateRandomVarValue(elemBasicType, rnd, samplerUnitCounter++) : es3fUniformApiTests.generateRandomVarValue(elemBasicType, rnd); basicUniformsDst.push(new es3fUniformApiTests.BasicUniform(indexedName, elemBasicType, isCurElemActive, value, arrayRootName, elemNdx, size)); } else samplerUnitCounter = this.generateBasicUniforms(basicUniformsDst, basicUniformReportsDst, varType.getElementType(), indexedName, isCurElemActive, samplerUnitCounter, rnd); } if (varType.getElementType().isBasicType()) { /** @type {number} */ var minSize; for (minSize = varType.getArraySize(); minSize > 0 && !isElemActive[minSize - 1]; minSize--) {} basicUniformReportsDst.push(new es3fUniformApiTests.BasicUniformReportRef(arrayRootName, varType.getElementType().getBasicType(), isParentActive && minSize > 0).constructor_A(minSize, size)); } } else { assertMsgOptions( varType.isStructType(), 'es3fUniformApiTests.UniformCase.prototype.generateBasicUniforms - not a struct type', false, true ); /** @type {gluVarType.StructType} */ var structType = varType.getStruct(); for (var i = 0; i < structType.getSize(); i++) { /** @type {gluVarType.StructMember} */ var member = structType.getMember(i); /** @type {string} */ var memberFullName = '' + varName + '.' + member.getName(); samplerUnitCounter = this.generateBasicUniforms(basicUniformsDst, basicUniformReportsDst, member.getType(), memberFullName, isParentActive, samplerUnitCounter, rnd); } } return samplerUnitCounter; }; /** * @param {string} dst * @return {string} */ es3fUniformApiTests.UniformCase.prototype.writeUniformDefinitions = function(dst) { for (var i = 0; i < this.m_uniformCollection.getNumStructTypes(); i++) dst += gluVarType.declareStructType(this.m_uniformCollection.getStructType(i), 0) + ';\n'; for (var i = 0; i < this.m_uniformCollection.getNumUniforms(); i++) dst += 'uniform ' + gluVarType.declareVariable(this.m_uniformCollection.getUniform(i).type, this.m_uniformCollection.getUniform(i).name, 0) + ';\n'; dst += '\n'; var compareFuncs = [{ requiringTypes: [gluShaderUtil.isDataTypeFloatOrVec, gluShaderUtil.isDataTypeMatrix], definition: 'mediump float compare_float (mediump float a, mediump float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_VEC2, t);}, function(t) {return es3fUniformApiTests.dataTypeIsMatrixWithNRows(2, t);} ], definition: 'mediump float compare_vec2 (mediump vec2 a, mediump vec2 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_VEC3, t);}, function(t) {return es3fUniformApiTests.dataTypeIsMatrixWithNRows(3, t);} ], definition: 'mediump float compare_vec3 (mediump vec3 a, mediump vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_VEC4, t);}, function(t) {return es3fUniformApiTests.dataTypeIsMatrixWithNRows(4, t);}], definition: 'mediump float compare_vec4 (mediump vec4 a, mediump vec4 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z)*compare_float(a.w, b.w); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT2, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat2 (mediump mat2 a, mediump mat2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT2X3, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat2x3 (mediump mat2x3 a, mediump mat2x3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT2X4, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat2x4 (mediump mat2x4 a, mediump mat2x4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT3X2, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat3x2 (mediump mat3x2 a, mediump mat3x2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT3, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat3 (mediump mat3 a, mediump mat3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT3X4, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat3x4 (mediump mat3x4 a, mediump mat3x4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT4X2, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat4x2 (mediump mat4x2 a, mediump mat4x2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2])*compare_vec2(a[3], b[3]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT4X3, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat4x3 (mediump mat4x3 a, mediump mat4x3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2])*compare_vec3(a[3], b[3]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.FLOAT_MAT4, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_mat4 (mediump mat4 a, mediump mat4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2])*compare_vec4(a[3], b[3]); }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INT, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_int (mediump int a, mediump int b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INT_VEC2, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_ivec2 (mediump ivec2 a, mediump ivec2 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INT_VEC3, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_ivec3 (mediump ivec3 a, mediump ivec3 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INT_VEC4, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_ivec4 (mediump ivec4 a, mediump ivec4 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.UINT, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_uint (mediump uint a, mediump uint b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.UINT_VEC2, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_uvec2 (mediump uvec2 a, mediump uvec2 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.UINT_VEC3, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_uvec3 (mediump uvec3 a, mediump uvec3 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.UINT_VEC4, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_uvec4 (mediump uvec4 a, mediump uvec4 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.BOOL, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_bool (bool a, bool b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.BOOL_VEC2, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_bvec2 (bvec2 a, bvec2 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.BOOL_VEC3, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_bvec3 (bvec3 a, bvec3 b) { return a == b ? 1.0 : 0.0; }' },{ requiringTypes: [ function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.BOOL_VEC4, t);}, function(t) {return es3fUniformApiTests.dataTypeEquals(gluShaderUtil.DataType.INVALID, t);} ], definition: 'mediump float compare_bvec4 (bvec4 a, bvec4 b) { return a == b ? 1.0 : 0.0; }' } ]; /** @type {Array} */ var samplerTypes = this.m_uniformCollection.getSamplerTypes(); for (var compFuncNdx = 0; compFuncNdx < compareFuncs.length; compFuncNdx++) { /** @type {Array} */ var typeReq = compareFuncs[compFuncNdx].requiringTypes; /** @type {boolean} */ var containsTypeSampler = false; for (var i = 0; i < samplerTypes.length; i++) { if (gluShaderUtil.isDataTypeSampler(samplerTypes[i])) { /** @type {gluShaderUtil.DataType} */ var retType = es3fUniformApiTests.getSamplerLookupReturnType(samplerTypes[i]); if (typeReq[0](retType) || typeReq[1](retType)) { containsTypeSampler = true; break; } } } if (containsTypeSampler || this.m_uniformCollection.containsMatchingBasicType(typeReq[0]) || this.m_uniformCollection.containsMatchingBasicType(typeReq[1])) dst += compareFuncs[compFuncNdx].definition + '\n'; } return dst; }; /** * @param {string} dst * @param {es3fUniformApiTests.BasicUniform} uniform * @return {string} Used to write the string in the output parameter */ es3fUniformApiTests.UniformCase.prototype.writeUniformCompareExpr = function(dst, uniform) { if (gluShaderUtil.isDataTypeSampler(uniform.type)) dst += 'compare_' + gluShaderUtil.getDataTypeName(es3fUniformApiTests.getSamplerLookupReturnType(uniform.type)) + '(texture(' + uniform.name + ', vec' + es3fUniformApiTests.getSamplerNumLookupDimensions(uniform.type) + '(0.0))'; //WebGL2.0 else dst += 'compare_' + gluShaderUtil.getDataTypeName(uniform.type) + '(' + uniform.name; dst += ', ' + es3fUniformApiTests.shaderVarValueStr(uniform.finalValue) + ')'; return dst; }; /** * @param {string} dst * @param {Array} basicUniforms * @param {string} variableName * @return {string} Used to write the string in the output parameter */ es3fUniformApiTests.UniformCase.prototype.writeUniformComparisons = function(dst, basicUniforms, variableName) { for (var i = 0; i < basicUniforms.length; i++) { /** @type {es3fUniformApiTests.BasicUniform} */ var unif = basicUniforms[i]; if (unif.isUsedInShader) { dst += '\t' + variableName + ' *= '; dst = this.writeUniformCompareExpr(dst, basicUniforms[i]); dst += ';\n'; } else dst += '\t// UNUSED: ' + basicUniforms[i].name + '\n'; } return dst; }; /** * @param {Array} basicUniforms * @return {string} */ es3fUniformApiTests.UniformCase.prototype.generateVertexSource = function(basicUniforms) { /** @type {boolean} */ var isVertexCase = this.m_caseShaderType == es3fUniformApiTests.CaseShaderType.VERTEX || this.m_caseShaderType == es3fUniformApiTests.CaseShaderType.BOTH; /** @type {string} */ var result = ''; result += '#version 300 es\n' + 'in highp vec4 a_position;\n' + 'out mediump float v_vtxOut;\n' + '\n'; if (isVertexCase) result = this.writeUniformDefinitions(result); result += '\n' + 'void main (void)\n' + ' {\n' + ' gl_Position = a_position;\n' + ' v_vtxOut = 1.0;\n'; if (isVertexCase) result = this.writeUniformComparisons(result, basicUniforms, 'v_vtxOut'); result += '}\n'; return result; }; /** * @param {Array} basicUniforms * @return {string} */ es3fUniformApiTests.UniformCase.prototype.generateFragmentSource = function(basicUniforms) { /**@type {boolean} */ var isFragmentCase = this.m_caseShaderType == es3fUniformApiTests.CaseShaderType.FRAGMENT || this.m_caseShaderType == es3fUniformApiTests.CaseShaderType.BOTH; /**@type {string} */ var result = ''; result += '#version 300 es\n' + 'in mediump float v_vtxOut;\n' + '\n'; if (isFragmentCase) result = this.writeUniformDefinitions(result); result += '\n' + 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n' + '\n' + 'void main (void)\n' + ' {\n' + ' mediump float result = v_vtxOut;\n'; if (isFragmentCase) result = this.writeUniformComparisons(result, basicUniforms, 'result'); result += ' dEQP_FragColor = vec4(result, result, result, 1.0);\n' + '}\n'; return result; }; /** * @param {es3fUniformApiTests.VarValue} value */ es3fUniformApiTests.UniformCase.prototype.setupTexture = function(value) { // \note No handling for samplers other than 2D or cube. assertMsgOptions( es3fUniformApiTests.getSamplerLookupReturnType(value.type) == gluShaderUtil.DataType.FLOAT_VEC4, 'es3fUniformApiTests.UniformCase.prototype.setupTexture - sampler return type should be vec4f', false, true ); /** @type {number} */ var width = 32; /** @type {number} */ var height = 32; /** @type {Array} */ var color = value.val.samplerV.fillColor; /** @type {tcuTexture.TextureCube} */ var refTexture; /** @type {gluTexture.TextureCube} */ var texture; if (value.type == gluShaderUtil.DataType.SAMPLER_2D) { texture = gluTexture.texture2DFromFormat(gl, gl.RGBA, gl.UNSIGNED_BYTE, width, height); refTexture = texture.getRefTexture(); this.m_textures2d.push(texture); refTexture.allocLevel(0); es3fUniformApiTests.fillWithColor(refTexture.getLevel(0), color); gl.activeTexture(gl.TEXTURE0 + value.val.samplerV.unit); this.m_filledTextureUnits.push(value.val.samplerV.unit); texture.upload(); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); } else if (value.type == gluShaderUtil.DataType.SAMPLER_CUBE) { assertMsgOptions(width == height, 'es3fUniformApiTests.UniformCase.prototype.setupTexture - non square texture', false, true); texture = gluTexture.cubeFromFormat(gl, gl.RGBA, gl.UNSIGNED_BYTE, width); refTexture = texture.getRefTexture(); this.m_texturesCube.push(texture); for (var face in tcuTexture.CubeFace) { refTexture.allocLevel(tcuTexture.CubeFace[face], 0); es3fUniformApiTests.fillWithColor(refTexture.getLevelFace(0, tcuTexture.CubeFace[face]), color); } gl.activeTexture(gl.TEXTURE0 + value.val.samplerV.unit); this.m_filledTextureUnits.push(value.val.samplerV.unit); texture.upload(); gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.NEAREST); } else throw new Error('es3fUniformApiTests.UniformCase.prototype.setupTexture - Invalid sampler type'); }; /** * @param {Array} basicUniformReportsDst * @param {Array} basicUniformReportsRef * @param {WebGLProgram} programGL * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.getActiveUniformsOneByOne = function(basicUniformReportsDst, basicUniformReportsRef, programGL) { /** @type {WebGLProgram} */ var numActiveUniforms; /** @type {boolean} */ var success = true; numActiveUniforms = /** @type {WebGLProgram} */ (gl.getProgramParameter(programGL, gl.ACTIVE_UNIFORMS)); bufferedLogToConsole('// Number of active uniforms reported: ' + numActiveUniforms); for (var unifNdx = 0; unifNdx < numActiveUniforms; unifNdx++) { /** @type {number} (GLint)*/ var reportedSize = -1; /** @type {number} (GLenum)*/ var reportedTypeGL = gl.NONE; /** @type {gluShaderUtil.DataType} */ var reportedType; /** @type {string} */ var reportedNameStr; /** @type {WebGLActiveInfo} */ var activeInfo; activeInfo = gl.getActiveUniform(programGL, unifNdx); reportedNameStr = activeInfo.name; reportedTypeGL = activeInfo.type; reportedSize = activeInfo.size; reportedType = gluShaderUtil.getDataTypeFromGLType(reportedTypeGL); checkMessage(reportedType !== undefined, 'Invalid uniform type'); bufferedLogToConsole('// Got name = ' + reportedNameStr + ', size = ' + reportedSize + ', type = ' + gluShaderUtil.getDataTypeName(reportedType)); // Ignore built-in uniforms. if (reportedNameStr.indexOf('gl_') == -1) { /** @type {number} */ var referenceNdx; for (referenceNdx = 0; referenceNdx < basicUniformReportsRef.length; referenceNdx++) { if (basicUniformReportsRef[referenceNdx].name == reportedNameStr) break; } if (referenceNdx >= basicUniformReportsRef.length) { bufferedLogToConsole('// FAILURE: invalid non-built-in uniform name reported'); success = false; } else { /** @type {es3fUniformApiTests.BasicUniformReportRef} */ var reference = basicUniformReportsRef[referenceNdx]; assertMsgOptions( reference.type !== undefined, 'es3fUniformApiTests.UniformCase.prototype.getActiveUniformsOneByOne - type is undefined', false, true ); assertMsgOptions( reference.minSize >= 1 || (reference.minSize == 0 && !reference.isUsedInShader), 'es3fUniformApiTests.UniformCase.prototype.getActiveUniformsOneByOne - uniform min size does not match usage in shader', false, true ); assertMsgOptions( reference.minSize <= reference.maxSize, 'es3fUniformApiTests.UniformCase.prototype.getActiveUniformsOneByOne - uniform min size bigger than max size', false, true ); if (es3fUniformApiTests.BasicUniformReportGL.findWithName(basicUniformReportsDst, reportedNameStr) !== null) { bufferedLogToConsole('// FAILURE: same uniform name reported twice'); success = false; } basicUniformReportsDst.push(new es3fUniformApiTests.BasicUniformReportGL(reportedNameStr, reportedNameStr.length, reportedSize, reportedType, unifNdx)); if (reportedType != reference.type) { bufferedLogToConsole('// FAILURE: wrong type reported, should be ' + gluShaderUtil.getDataTypeName(reference.type)); success = false; } if (reportedSize < reference.minSize || reportedSize > reference.maxSize) { bufferedLogToConsole('// FAILURE: wrong size reported, should be ' + (reference.minSize == reference.maxSize ? reference.minSize : 'in the range [' + reference.minSize + ', ' + reference.maxSize + ']')); success = false; } } } } for (var i = 0; i < basicUniformReportsRef.length; i++) { /** @type {es3fUniformApiTests.BasicUniformReportRef} */ var expected = basicUniformReportsRef[i]; if (expected.isUsedInShader && es3fUniformApiTests.BasicUniformReportGL.findWithName(basicUniformReportsDst, expected.name) === null) { bufferedLogToConsole('// FAILURE: uniform with name ' + expected.name + ' was not reported by GL'); success = false; } } return success; }; /** * @param {Array} basicUniformReportsDst * @param {Array} basicUniformReportsRef * @param {WebGLProgram} programGL * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.getActiveUniforms = function(basicUniformReportsDst, basicUniformReportsRef, programGL) { /** @type {Array} */ var queryNames = new Array(basicUniformReportsRef.length); /** @type {Array} */ var queryNamesC = new Array(basicUniformReportsRef.length); /** @type {Array} (GLuint) */ var uniformIndices = new Array(basicUniformReportsRef.length); /** @type {Array} */ var validUniformIndices = []; // This shall have the same contents, and in same order, as uniformIndices, but with gl.INVALID_INDEX entries removed. /** @type {boolean} */ var success = true; for (var i = 0; i < basicUniformReportsRef.length; i++) { /** @type {string} */ var name = basicUniformReportsRef[i].name; queryNames[i] = this.m_features.ARRAY_FIRST_ELEM_NAME_NO_INDEX && name[name.length - 1] == ']' ? es3fUniformApiTests.beforeLast(name, '[') : name; queryNamesC[i] = queryNames[i]; } uniformIndices = gl.getUniformIndices(programGL, queryNamesC); for (var i = 0; i < uniformIndices.length; i++) { if (uniformIndices[i] != gl.INVALID_INDEX) validUniformIndices.push(uniformIndices[i]); else { if (basicUniformReportsRef[i].isUsedInShader) { bufferedLogToConsole('// FAILURE: uniform with name ' + basicUniformReportsRef[i].name + ' received gl.INVALID_INDEX'); success = false; } } } if (validUniformIndices.length > 0) { /** @type {Array} */ var uniformNameBuf = new Array(validUniformIndices.length); /** @type {Array} (GLint) */ var uniformSizeBuf = new Array(validUniformIndices.length); /** @type {Array} (GLint) */ var uniformTypeBuf = new Array(validUniformIndices.length); uniformSizeBuf = gl.getActiveUniforms(programGL, validUniformIndices, gl.UNIFORM_SIZE); uniformTypeBuf = gl.getActiveUniforms(programGL, validUniformIndices, gl.UNIFORM_TYPE); /** @type {number} */ var validNdx = -1; // Keeps the corresponding index to validUniformIndices while unifNdx is the index to uniformIndices. for (var unifNdx = 0; unifNdx < uniformIndices.length; unifNdx++) { if (uniformIndices[unifNdx] == gl.INVALID_INDEX) continue; validNdx++; /** @type {es3fUniformApiTests.BasicUniformReportRef} */ var reference = basicUniformReportsRef[unifNdx]; /** @type {number} */ var reportedIndex = validUniformIndices[validNdx]; /** @type {number} */ var reportedNameLength = reference.name.length; /** @type {number} */ var reportedSize = uniformSizeBuf[validNdx]; /** @type {gluShaderUtil.DataType} */ var reportedType = gluShaderUtil.getDataTypeFromGLType(uniformTypeBuf[validNdx]); /** @type {string} */ var reportedNameStr = reference.name; bufferedLogToConsole('// Got name size = ' + reportedSize + ', type = ' + gluShaderUtil.getDataTypeName(reportedType) + ' for the uniform at index ' + reportedIndex + ' (' + reference.name + ')'); assertMsgOptions( reference.type !== undefined, 'es3fUniformApiTests.UniformCase.prototype.getActiveUniforms - type is undefined', false, true ); assertMsgOptions( reference.minSize >= 1 || (reference.minSize == 0 && !reference.isUsedInShader), 'es3fUniformApiTests.UniformCase.prototype.getActiveUniforms - uniform min size does not match usage in shader', false, true ); assertMsgOptions( reference.minSize <= reference.maxSize, 'es3fUniformApiTests.UniformCase.prototype.getActiveUniforms - uniform min size bigger than max size', false, true ); if (es3fUniformApiTests.BasicUniformReportGL.findWithName(basicUniformReportsDst, reportedNameStr) !== null) { bufferedLogToConsole('// FAILURE: same uniform name reported twice'); success = false; } basicUniformReportsDst.push(new es3fUniformApiTests.BasicUniformReportGL(reference.name, reportedNameLength, reportedSize, reportedType, reportedIndex)); if (reportedType != reference.type) { bufferedLogToConsole('// FAILURE: wrong type reported, should be ' + gluShaderUtil.getDataTypeName(reference.type)); success = false; } if (reportedSize < reference.minSize || reportedSize > reference.maxSize) { bufferedLogToConsole('// FAILURE: wrong size reported, should be ' + (reference.minSize == reference.maxSize ? reference.minSize : 'in the range [' + reference.minSize + ', ' + reference.maxSize + ']')); success = false; } } } return success; }; /** * @param {Array} uniformResults * @param {Array} uniformsResults * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.uniformVsUniformsComparison = function(uniformResults, uniformsResults) { /** @type {boolean} */ var success = true; /** @type {es3fUniformApiTests.BasicUniformReportGL} */ var uniformsResult; for (var uniformResultNdx = 0; uniformResultNdx < uniformResults.length; uniformResultNdx++) { /** @type {es3fUniformApiTests.BasicUniformReportGL} */ var uniformResult = uniformResults[uniformResultNdx]; /** @type {string} */ var uniformName = uniformResult.name; uniformsResult = es3fUniformApiTests.BasicUniformReportGL.findWithName(uniformsResults, uniformName); if (uniformsResult !== null) { bufferedLogToConsole('// Checking uniform ' + uniformName); if (uniformResult.index != uniformsResult.index) { bufferedLogToConsole('// FAILURE: glGetActiveUniform() and glGetUniformIndices() gave different indices for uniform ' + uniformName); success = false; } if (uniformResult.nameLength != uniformsResult.nameLength) { bufferedLogToConsole('// FAILURE: glGetActiveUniform() and glGetActiveUniforms() gave incompatible name lengths for uniform ' + uniformName); success = false; } if (uniformResult.size != uniformsResult.size) { bufferedLogToConsole('// FAILURE: glGetActiveUniform() and glGetActiveUniforms() gave different sizes for uniform ' + uniformName); success = false; } if (uniformResult.type != uniformsResult.type) { bufferedLogToConsole('// FAILURE: glGetActiveUniform() and glGetActiveUniforms() gave different types for uniform ' + uniformName); success = false; } } else { bufferedLogToConsole('// FAILURE: uniform ' + uniformName + ' was reported active by glGetActiveUniform() but not by glGetUniformIndices()'); success = false; } } for (var uniformsResultNdx = 0; uniformsResultNdx < uniformsResults.length; uniformsResultNdx++) { uniformsResult = uniformsResults[uniformsResultNdx]; /** @type {string} */ var uniformsName = uniformsResult.name; /** @type {es3fUniformApiTests.BasicUniformReportGL} */ var uniformsResultIt = es3fUniformApiTests.BasicUniformReportGL.findWithName(uniformsResults, uniformsName); if (uniformsResultIt === null) { bufferedLogToConsole('// FAILURE: uniform ' + uniformsName + ' was reported active by glGetUniformIndices() but not by glGetActiveUniform()'); success = false; } } return success; }; /** * @param {Array} valuesDst * @param {Array} basicUniforms * @param {WebGLProgram} programGL * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.getUniforms = function(valuesDst, basicUniforms, programGL) { /** @type {boolean} */ var success = true; for (var unifNdx = 0; unifNdx < basicUniforms.length; unifNdx++) { /** @type {es3fUniformApiTests.BasicUniform} */ var uniform = basicUniforms[unifNdx]; /** @type {string} */ var queryName = this.m_features.ARRAY_FIRST_ELEM_NAME_NO_INDEX && uniform.elemNdx == 0 ? es3fUniformApiTests.beforeLast(uniform.name, '[') : uniform.name; /** @type {WebGLUniformLocation} */ var location = gl.getUniformLocation(programGL, queryName); /** @type {number} */ var size = gluShaderUtil.getDataTypeScalarSize(uniform.type); /** @type {es3fUniformApiTests.VarValue} */ var value = new es3fUniformApiTests.VarValue(); if (!location) { value.type = gluShaderUtil.DataType.INVALID; valuesDst.push(value); if (uniform.isUsedInShader) { bufferedLogToConsole('// FAILURE: ' + uniform.name + ' was used in shader, but has location -1'); success = false; } continue; } value.type = uniform.type; var result = /** @type {number} */ (gl.getUniform(programGL, location)); if (gluShaderUtil.isDataTypeSampler(uniform.type)) { value.val = new es3fUniformApiTests.SamplerV(); value.val.samplerV.unit = result; } else value.val = /** @type {Array} */ (result.length === undefined ? [result] : result); valuesDst.push(value); bufferedLogToConsole('// Got ' + uniform.name + ' value ' + es3fUniformApiTests.apiVarValueStr(value)); } return success; }; /** * @param {Array} values * @param {Array} basicUniforms * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.checkUniformDefaultValues = function(values, basicUniforms) { /** @type {boolean} */ var success = true; assertMsgOptions( values.length == basicUniforms.length, 'es3fUniformApiTests.UniformCase.prototype.checkUniformDefaultValues - lengths do not match', false, true ); for (var unifNdx = 0; unifNdx < basicUniforms.length; unifNdx++) { /** @type {es3fUniformApiTests.BasicUniform} */ var uniform = basicUniforms[unifNdx]; /** @type {es3fUniformApiTests.VarValue} */ var unifValue = values[unifNdx]; /** @type {number} */ var valSize = gluShaderUtil.getDataTypeScalarSize(uniform.type); bufferedLogToConsole('// Checking uniform ' + uniform.name); if (unifValue.type == gluShaderUtil.DataType.INVALID) // This happens when glGetUniformLocation() returned -1. continue; var CHECK_UNIFORM = function(ZERO) { do { for (var i = 0; i < valSize; i++) { if (unifValue.val[i] != ZERO) { bufferedLogToConsole('// FAILURE: uniform ' + uniform.name + ' has non-zero initial value'); success = false; } } } while (false); }; if (gluShaderUtil.isDataTypeFloatOrVec(uniform.type) || gluShaderUtil.isDataTypeMatrix(uniform.type)) CHECK_UNIFORM(0.0); else if (gluShaderUtil.isDataTypeIntOrIVec(uniform.type)) CHECK_UNIFORM(0); else if (gluShaderUtil.isDataTypeUintOrUVec(uniform.type)) CHECK_UNIFORM(0); else if (gluShaderUtil.isDataTypeBoolOrBVec(uniform.type)) CHECK_UNIFORM(false); else if (gluShaderUtil.isDataTypeSampler(uniform.type)) { if (unifValue.val.samplerV.unit != 0) { bufferedLogToConsole('// FAILURE: uniform ' + uniform.name + ' has non-zero initial value'); success = false; } } else throw new Error('es3fUniformApiTests.UniformCase.prototype.checkUniformDefaultValues - invalid uniform type'); } return success; }; /** * @param {Array} basicUniforms * @param {WebGLProgram} programGL * @param {deRandom.Random} rnd */ es3fUniformApiTests.UniformCase.prototype.assignUniforms = function(basicUniforms, programGL, rnd) { /** @type {boolean} */ var transpose = false; //No support to transpose uniform matrices in WebGL, must always be false. (this.m_features.MATRIXMODE_ROWMAJOR) != 0; /** @type {boolean} (GLboolean) */ var transposeGL = transpose; /** @type {gluShaderUtil.DataType} */ var boolApiType = this.m_features.BOOLEANAPITYPE_INT ? gluShaderUtil.DataType.INT : this.m_features.BOOLEANAPITYPE_UINT ? gluShaderUtil.DataType.UINT : gluShaderUtil.DataType.FLOAT; for (var unifNdx = 0; unifNdx < basicUniforms.length; unifNdx++) { /** @type {es3fUniformApiTests.BasicUniform} */ var uniform = basicUniforms[unifNdx]; /** @type {boolean} */ var isArrayMember = uniform.elemNdx >= 0; /** @type {string} */ var queryName = this.m_features.ARRAY_FIRST_ELEM_NAME_NO_INDEX && uniform.elemNdx == 0 ? es3fUniformApiTests.beforeLast(uniform.name, '[') : uniform.name; /** @type {number} */ var numValuesToAssign = !isArrayMember ? 1 : this.m_features.ARRAYASSIGN_FULL ? (uniform.elemNdx == 0 ? uniform.rootSize : 0) : this.m_features.ARRAYASSIGN_BLOCKS_OF_TWO ? (uniform.elemNdx % 2 == 0 ? 2 : 0) : /* Default: assign array elements separately */ 1; assertMsgOptions( numValuesToAssign >= 0, 'es3fUniformApiTests.UniformCase.prototype.assignUniforms - number of values to assign not a positive integer', false, true ); assertMsgOptions( numValuesToAssign == 1 || isArrayMember, 'es3fUniformApiTests.UniformCase.prototype.assignUniforms - not an array member and number of values to assign not 1', false, true ); if (numValuesToAssign == 0) { bufferedLogToConsole('// es3fUniformApiTests.Uniform ' + uniform.name + ' is covered by another glUniform*v() call to the same array'); continue; } /** @type {WebGLUniformLocation} */ var location = gl.getUniformLocation(programGL, queryName); /** @type {number} */ var typeSize = gluShaderUtil.getDataTypeScalarSize(uniform.type); /** @type {boolean} */ var assignByValue = this.m_features.UNIFORMFUNC_VALUE && !gluShaderUtil.isDataTypeMatrix(uniform.type) && numValuesToAssign == 1; /** @type {Array} */ var valuesToAssign = []; /** @type {Array} */ var buffer; for (var i = 0; i < numValuesToAssign; i++) { /** @type {string} */ var curName = isArrayMember ? es3fUniformApiTests.beforeLast(uniform.rootName, '[') + '[' + (uniform.elemNdx + i) + ']' : uniform.name; /** @type {es3fUniformApiTests.VarValue} */ var unifValue = new es3fUniformApiTests.VarValue(); if (isArrayMember) { /** @type {es3fUniformApiTests.BasicUniform} */ var elemUnif = es3fUniformApiTests.BasicUniform.findWithName(basicUniforms, curName); if (elemUnif === null) continue; unifValue = elemUnif.finalValue; } else unifValue = uniform.finalValue; /** @type {es3fUniformApiTests.VarValue} */ var apiValue = gluShaderUtil.isDataTypeBoolOrBVec(unifValue.type) ? es3fUniformApiTests.getRandomBoolRepresentation(unifValue, boolApiType, rnd) : gluShaderUtil.isDataTypeSampler(unifValue.type) ? es3fUniformApiTests.getSamplerUnitValue(unifValue) : unifValue; valuesToAssign.push(gluShaderUtil.isDataTypeMatrix(apiValue.type) && transpose ? es3fUniformApiTests.getTransposeMatrix(apiValue) : apiValue); if (gluShaderUtil.isDataTypeBoolOrBVec(uniform.type)) bufferedLogToConsole('// Using type ' + gluShaderUtil.getDataTypeName(boolApiType) + ' to set boolean value ' + es3fUniformApiTests.apiVarValueStr(unifValue) + ' for ' + curName); else if (gluShaderUtil.isDataTypeSampler(uniform.type)) bufferedLogToConsole('// Texture for the sampler uniform ' + curName + ' will be filled with color ' + es3fUniformApiTests.apiVarValueStr(es3fUniformApiTests.getSamplerFillValue(uniform.finalValue))); } assertMsgOptions( valuesToAssign.length > 0, 'es3fUniformApiTests.UniformCase.prototype.assignUniforms - values quantity less than one', false, true ); if (gluShaderUtil.isDataTypeFloatOrVec(valuesToAssign[0].type)) { if (assignByValue) { switch (typeSize) { case 1: gl.uniform1f(location, valuesToAssign[0].val[0]); break; case 2: gl.uniform2f(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1]); break; case 3: gl.uniform3f(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1], valuesToAssign[0].val[2]); break; case 4: gl.uniform4f(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1], valuesToAssign[0].val[2], valuesToAssign[0].val[3]); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid type size'); } } else { buffer = new Array(valuesToAssign.length * typeSize); for (var i = 0; i < buffer.length; i++) buffer[i] = valuesToAssign[Math.floor(i / typeSize)].val[i % typeSize]; switch (typeSize) { case 1: gl.uniform1fv(location, buffer); break; case 2: gl.uniform2fv(location, buffer); break; case 3: gl.uniform3fv(location, buffer); break; case 4: gl.uniform4fv(location, buffer); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid type size'); } } } else if (gluShaderUtil.isDataTypeMatrix(valuesToAssign[0].type)) { assertMsgOptions( !assignByValue, 'es3fUniformApiTests.UniformCase.prototype.assignUniforms - assigning by value in matrix type', false, true ); buffer = new Array(valuesToAssign.length * typeSize); for (var i = 0; i < buffer.length; i++) buffer[i] = valuesToAssign[Math.floor(i / typeSize)].val[i % typeSize]; switch (uniform.type) { case gluShaderUtil.DataType.FLOAT_MAT2: gl.uniformMatrix2fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT3: gl.uniformMatrix3fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT4: gl.uniformMatrix4fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT2X3: gl.uniformMatrix2x3fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT2X4: gl.uniformMatrix2x4fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT3X2: gl.uniformMatrix3x2fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT3X4: gl.uniformMatrix3x4fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT4X2: gl.uniformMatrix4x2fv(location, transposeGL, new Float32Array(buffer)); break; case gluShaderUtil.DataType.FLOAT_MAT4X3: gl.uniformMatrix4x3fv(location, transposeGL, new Float32Array(buffer)); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid uniform type'); } } else if (gluShaderUtil.isDataTypeIntOrIVec(valuesToAssign[0].type)) { if (assignByValue) { switch (typeSize) { case 1: gl.uniform1i(location, valuesToAssign[0].val[0]); break; case 2: gl.uniform2i(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1]); break; case 3: gl.uniform3i(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1], valuesToAssign[0].val[2]); break; case 4: gl.uniform4i(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1], valuesToAssign[0].val[2], valuesToAssign[0].val[3]); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid type size'); } } else { buffer = new Array(valuesToAssign.length * typeSize); for (var i = 0; i < buffer.length; i++) buffer[i] = valuesToAssign[Math.floor(i / typeSize)].val[i % typeSize]; switch (typeSize) { case 1: gl.uniform1iv(location, buffer); break; case 2: gl.uniform2iv(location, buffer); break; case 3: gl.uniform3iv(location, buffer); break; case 4: gl.uniform4iv(location, buffer); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid type size'); } } } else if (gluShaderUtil.isDataTypeUintOrUVec(valuesToAssign[0].type)) { if (assignByValue) { switch (typeSize) { case 1: gl.uniform1ui(location, valuesToAssign[0].val[0]); break; case 2: gl.uniform2ui(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1]); break; case 3: gl.uniform3ui(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1], valuesToAssign[0].val[2]); break; case 4: gl.uniform4ui(location, valuesToAssign[0].val[0], valuesToAssign[0].val[1], valuesToAssign[0].val[2], valuesToAssign[0].val[3]); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid type size'); } } else { buffer = new Array(valuesToAssign.length * typeSize); for (var i = 0; i < buffer.length; i++) buffer[i] = valuesToAssign[Math.floor(i / typeSize)].val[i % typeSize]; switch (typeSize) { case 1: gl.uniform1uiv(location, buffer); break; case 2: gl.uniform2uiv(location, buffer); break; case 3: gl.uniform3uiv(location, buffer); break; case 4: gl.uniform4uiv(location, buffer); break; default: throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid type size'); } } } else if (gluShaderUtil.isDataTypeSampler(valuesToAssign[0].type)) { if (assignByValue) gl.uniform1i(location, uniform.finalValue.val.samplerV.unit); else { var unit = /** @type {Array} */ (uniform.finalValue.val); gl.uniform1iv(location, unit); } } else throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid uniform type'); } }; /** * @param {Array} values * @param {Array} basicUniforms * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.compareUniformValues = function(values, basicUniforms) { /** @type {boolean} */ var success = true; for (var unifNdx = 0; unifNdx < basicUniforms.length; unifNdx++) { /** @type {es3fUniformApiTests.BasicUniform} */ var uniform = basicUniforms[unifNdx]; /** @type {es3fUniformApiTests.VarValue} */ var unifValue = values[unifNdx]; bufferedLogToConsole('// Checking uniform ' + uniform.name); if (unifValue.type == gluShaderUtil.DataType.INVALID) // This happens when glGetUniformLocation() returned -1. continue; if (!es3fUniformApiTests.apiVarValueEquals(unifValue, uniform.finalValue)) { bufferedLogToConsole('// FAILURE: value obtained with glGetUniform*() for uniform ' + uniform.name + ' differs from value set with glUniform*()'); success = false; } } return success; }; /** @const @type {number} */ es3fUniformApiTests.VIEWPORT_WIDTH = 128; /** @const @type {number} */ es3fUniformApiTests.VIEWPORT_HEIGHT = 128; /** * @param {Array} basicUniforms * @param {gluShaderProgram.ShaderProgram} program * @param {deRandom.Random} rnd * @return {boolean} */ es3fUniformApiTests.UniformCase.prototype.renderTest = function(basicUniforms, program, rnd) { //const tcu::RenderTarget& renderTarget = m_context.getRenderTarget(); /** @const */ var viewportW = Math.min(gl.canvas.width, es3fUniformApiTests.VIEWPORT_WIDTH); /** @const */ var viewportH = Math.min(gl.canvas.height, es3fUniformApiTests.VIEWPORT_HEIGHT); /** @const */ var viewportX = rnd.getInt(0, gl.canvas.width - viewportW); /** @const */ var viewportY = rnd.getInt(0, gl.canvas.height - viewportH); /** @type {tcuSurface.Surface} */ var renderedImg = new tcuSurface.Surface(viewportW, viewportH); // Assert that no two samplers of different types have the same texture unit - this is an error in GL. for (var i = 0; i < basicUniforms.length; i++) { if (gluShaderUtil.isDataTypeSampler(basicUniforms[i].type)) { for (var j = 0; j < i; j++) { if (gluShaderUtil.isDataTypeSampler(basicUniforms[j].type) && basicUniforms[i].type != basicUniforms[j].type) assertMsgOptions( basicUniforms[i].finalValue.val.samplerV.unit != basicUniforms[j].finalValue.val.samplerV.unit, 'es3fUniformApiTests.UniformCase.prototype.renderTest - sampler units have the same texture unit', false, true ); } } } for (var i = 0; i < basicUniforms.length; i++) { if (gluShaderUtil.isDataTypeSampler(basicUniforms[i].type) && this.m_filledTextureUnits.indexOf(basicUniforms[i].finalValue.val) == -1) { bufferedLogToConsole('// Filling texture at unit ' + es3fUniformApiTests.apiVarValueStr(basicUniforms[i].finalValue) + ' with color ' + es3fUniformApiTests.shaderVarValueStr(basicUniforms[i].finalValue)); this.setupTexture(basicUniforms[i].finalValue); } } gl.viewport(viewportX, viewportY, viewportW, viewportH); /** @type {Float32Array} */ var position = new Float32Array([ -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 {Uint16Array} */ var indices = new Uint16Array([0, 1, 2, 2, 1, 3]); /** @type {number} */ var posLoc = gl.getAttribLocation(program.getProgram(), 'a_position'); gl.enableVertexAttribArray(posLoc); var gl_position_buffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, gl_position_buffer); gl.bufferData(gl.ARRAY_BUFFER, position, gl.STATIC_DRAW); gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0); var gl_index_buffer = gl.createBuffer(); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, gl_index_buffer); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW); gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0); renderedImg.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]); /** @type {number} */ var numFailedPixels = 0; var whitePixel = new gluDrawUtil.Pixel([255.0, 255.0, 255.0, 255.0]); for (var y = 0; y < renderedImg.getHeight(); y++) { for (var x = 0; x < renderedImg.getWidth(); x++) { var currentPixel = new gluDrawUtil.Pixel(renderedImg.getPixel(x, y)); if (!whitePixel.equals(currentPixel)) numFailedPixels += 1; } } if (numFailedPixels > 0) { //TODO: log << TestLog::Image("RenderedImage", "Rendered image", renderedImg); bufferedLogToConsole('FAILURE: image comparison failed, got ' + numFailedPixels + ' non-white pixels'); return false; } else { bufferedLogToConsole('Success: got all-white pixels (all uniforms have correct values)'); return true; } }; /** * @return {tcuTestCase.IterateResult} */ es3fUniformApiTests.UniformCase.prototype.iterate = function() { /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name) ^ deRandom.getBaseSeed()); /** @type {Array} */ var basicUniforms = []; /** @type {Array} */ var basicUniformReportsRef = []; /** @type {number} */ var samplerUnitCounter = 0; for (var i = 0; i < this.m_uniformCollection.getNumUniforms(); i++) samplerUnitCounter = this.generateBasicUniforms(basicUniforms, basicUniformReportsRef, this.m_uniformCollection.getUniform(i).type, this.m_uniformCollection.getUniform(i).name, true, samplerUnitCounter, rnd); /** @type {string} */ var vertexSource = this.generateVertexSource(basicUniforms); /** @type {string} */ var fragmentSource = this.generateFragmentSource(basicUniforms); /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexSource, fragmentSource)); bufferedLogToConsole(program.getProgramInfo().infoLog); if (!program.isOk()) { testFailedOptions('Compile failed', false); return tcuTestCase.IterateResult.STOP; } gl.useProgram(program.getProgram()); /** @type {boolean} */ var success = this.test(basicUniforms, basicUniformReportsRef, program, rnd); assertMsgOptions(success, '', true, false); return tcuTestCase.IterateResult.STOP; }; /** * @enum {number} */ es3fUniformApiTests.CaseType = { UNIFORM: 0, //!< Check info returned by glGetActiveUniform(). INDICES_UNIFORMSIV: 1, //!< Check info returned by glGetUniformIndices() + glGetActiveUniforms(). TODO: Check 'IV' part CONSISTENCY: 2 //!< Query info with both above methods, and check consistency. }; /** * es3fUniformApiTests.UniformInfoQueryCase class * @constructor * @param {string} name * @param {string} description * @param {es3fUniformApiTests.CaseShaderType} shaderType * @param {es3fUniformApiTests.UniformCollection} uniformCollection * @param {es3fUniformApiTests.CaseType} caseType * @param {es3fUniformApiTests.Feature} additionalFeatures * @extends {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformInfoQueryCase = function(name, description, shaderType, uniformCollection, caseType, additionalFeatures) { es3fUniformApiTests.UniformCase.call(this, name, description); this.newB(shaderType, uniformCollection, additionalFeatures); /** @type {es3fUniformApiTests.CaseType} */ this.m_caseType = caseType; }; es3fUniformApiTests.UniformInfoQueryCase.prototype = Object.create(es3fUniformApiTests.UniformCase.prototype); /** Constructor restore */ es3fUniformApiTests.UniformInfoQueryCase.prototype.constructor = es3fUniformApiTests.UniformInfoQueryCase; /** * @param {es3fUniformApiTests.CaseType} caseType * @return {?string} */ es3fUniformApiTests.UniformInfoQueryCase.getCaseTypeName = function(caseType) { switch (caseType) { case es3fUniformApiTests.CaseType.UNIFORM: return 'active_uniform'; case es3fUniformApiTests.CaseType.INDICES_UNIFORMSIV: return 'indices_active_uniformsiv'; case es3fUniformApiTests.CaseType.CONSISTENCY: return 'consistency'; default: throw new Error('Invalid type'); } }; /** * @param {es3fUniformApiTests.CaseType} caseType * @return {?string} */ es3fUniformApiTests.UniformInfoQueryCase.getCaseTypeDescription = function(caseType) { switch (caseType) { case es3fUniformApiTests.CaseType.UNIFORM: return 'Test glGetActiveUniform()'; case es3fUniformApiTests.CaseType.INDICES_UNIFORMSIV: return 'Test glGetUniformIndices() along with glGetActiveUniforms()'; case es3fUniformApiTests.CaseType.CONSISTENCY: return 'Check consistency between results from glGetActiveUniform() and glGetUniformIndices() + glGetActiveUniforms()'; default: throw new Error('Invalid type'); } }; // \note Although this is only used in UniformApiTest::es3fUniformApiTests.init, it needs to be defined here as it's used as a template argument. /** * @constructor * @param {?string} name * @param {es3fUniformApiTests.UniformCollection} uniformCollection_ */ es3fUniformApiTests.UniformCollectionCase = function(name, uniformCollection_) { /** @type {string} */ this.namePrefix = name ? name + '_' : ''; /** @type {es3fUniformApiTests.UniformCollection} (SharedPtr) */ this.uniformCollection = uniformCollection_; }; /** * @param {Array} basicUniforms * @param {Array} basicUniformReportsRef * @param {gluShaderProgram.ShaderProgram} program * @param {deRandom.Random} rnd * @return {boolean} */ es3fUniformApiTests.UniformInfoQueryCase.prototype.test = function(basicUniforms, basicUniformReportsRef, program, rnd) { /** @type {WebGLProgram} */ var programGL = program.getProgram(); /** @type {Array} */ var basicUniformReportsUniform = []; /** @type {Array} */ var basicUniformReportsUniforms = []; /** @type {boolean} */ var success; if (this.m_caseType == es3fUniformApiTests.CaseType.UNIFORM || this.m_caseType == es3fUniformApiTests.CaseType.CONSISTENCY) { success = false; //TODO:: const ScopedLogSection section(log, "InfoGetActiveUniform", "es3fUniformApiTests.Uniform information queries with glGetActiveUniform()"); success = this.getActiveUniformsOneByOne(basicUniformReportsUniform, basicUniformReportsRef, programGL); if (!success) { if (this.m_caseType == es3fUniformApiTests.CaseType.UNIFORM) return false; else { assertMsgOptions( this.m_caseType == es3fUniformApiTests.CaseType.CONSISTENCY, 'es3fUniformApiTests.UniformInfoQueryCase.prototype.test - case type is not consistency', false, true ); bufferedLogToConsole('// Note: this is a consistency case, so ignoring above failure(s)'); } } } if (this.m_caseType == es3fUniformApiTests.CaseType.INDICES_UNIFORMSIV || this.m_caseType == es3fUniformApiTests.CaseType.CONSISTENCY) { success = false; //TODO: const ScopedLogSection section(log, "InfoGetActiveUniforms", "es3fUniformApiTests.Uniform information queries with glGetUniformIndices() and glGetActiveUniforms()"); success = this.getActiveUniforms(basicUniformReportsUniforms, basicUniformReportsRef, programGL); if (!success) { if (this.m_caseType == es3fUniformApiTests.CaseType.INDICES_UNIFORMSIV) return false; else { assertMsgOptions( this.m_caseType == es3fUniformApiTests.CaseType.CONSISTENCY, 'es3fUniformApiTests.UniformInfoQueryCase.prototype.test - case type is not consistency', false, true ); bufferedLogToConsole('// Note: this is a consistency case, so ignoring above failure(s)'); } } } if (this.m_caseType == es3fUniformApiTests.CaseType.CONSISTENCY) { success = false; //TODO: const ScopedLogSection section(log, "CompareUniformVsUniforms", "Comparison of results from glGetActiveUniform() and glGetActiveUniforms()"); success = this.uniformVsUniformsComparison(basicUniformReportsUniform, basicUniformReportsUniforms); if (!success) return false; } return true; }; /** * @enum {number} */ es3fUniformApiTests.ValueToCheck = { INITIAL: 0, //!< Verify the initial values of the uniforms (i.e. check that they're zero). ASSIGNED: 1 //!< Assign values to uniforms with glUniform*(), and check those. }; /** * @enum {number} */ es3fUniformApiTests.CheckMethod = { GET_UNIFORM: 0, //!< Check values with glGetUniform*(). RENDER: 1 //!< Check values by rendering with the value-checking shader. }; /** * @enum {number} */ es3fUniformApiTests.AssignMethod = { POINTER: 0, VALUE: 1 }; /** * es3fUniformApiTests.UniformValueCase test class * @constructor * @param {string} name * @param {string} description * @param {es3fUniformApiTests.CaseShaderType} shaderType * @param {es3fUniformApiTests.UniformCollection} uniformCollection (SharedPtr) * @param {es3fUniformApiTests.ValueToCheck} valueToCheck * @param {es3fUniformApiTests.CheckMethod} checkMethod * @param {?es3fUniformApiTests.AssignMethod} assignMethod * @param {es3fUniformApiTests.Feature} additionalFeatures * @extends {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.UniformValueCase = function(name, description, shaderType, uniformCollection, valueToCheck, checkMethod, assignMethod, additionalFeatures) { es3fUniformApiTests.UniformCase.call(this, name, description); additionalFeatures.UNIFORMVALUE_ZERO |= valueToCheck == es3fUniformApiTests.ValueToCheck.INITIAL; additionalFeatures.UNIFORMFUNC_VALUE |= assignMethod == es3fUniformApiTests.AssignMethod.VALUE; this.newB(shaderType, uniformCollection, additionalFeatures); this.m_valueToCheck = valueToCheck; this.m_checkMethod = checkMethod; assertMsgOptions( !(assignMethod === undefined && valueToCheck == es3fUniformApiTests.ValueToCheck.ASSIGNED), 'es3fUniformApiTests.UniformValueCase - assign method is undefined when value to check requires it', false, true ); }; es3fUniformApiTests.UniformValueCase.prototype = Object.create(es3fUniformApiTests.UniformCase.prototype); /** Constructor restore */ es3fUniformApiTests.UniformValueCase.prototype.constructor = es3fUniformApiTests.UniformValueCase; /** * @param {es3fUniformApiTests.ValueToCheck} valueToCheck * @return {?string} */ es3fUniformApiTests.UniformValueCase.getValueToCheckName = function(valueToCheck) { switch (valueToCheck) { case es3fUniformApiTests.ValueToCheck.INITIAL: return 'initial'; case es3fUniformApiTests.ValueToCheck.ASSIGNED: return 'assigned'; default: throw new Error('es3fUniformApiTests.UniformValueCase.getValueToCheckName - Invalid value to check option'); } }; /** * @param {es3fUniformApiTests.ValueToCheck} valueToCheck * @return {?string} */ es3fUniformApiTests.UniformValueCase.getValueToCheckDescription = function(valueToCheck) { switch (valueToCheck) { case es3fUniformApiTests.ValueToCheck.INITIAL: return 'Check initial uniform values (zeros)'; case es3fUniformApiTests.ValueToCheck.ASSIGNED: return 'Check assigned uniform values'; default: throw new Error('es3fUniformApiTests.UniformValueCase.getValueToCheckDescription - Invalid value to check option'); } }; /** * @param {es3fUniformApiTests.CheckMethod} checkMethod * @return {?string} */ es3fUniformApiTests.UniformValueCase.getCheckMethodName = function(checkMethod) { switch (checkMethod) { case es3fUniformApiTests.CheckMethod.GET_UNIFORM: return 'get_uniform'; case es3fUniformApiTests.CheckMethod.RENDER: return 'render'; default: throw new Error('es3fUniformApiTests.UniformValueCase.getCheckMethodName - Invalid check method'); } }; /** * @param {es3fUniformApiTests.CheckMethod} checkMethod * @return {?string} */ es3fUniformApiTests.UniformValueCase.getCheckMethodDescription = function(checkMethod) { switch (checkMethod) { case es3fUniformApiTests.CheckMethod.GET_UNIFORM: return 'Verify values with glGetUniform*()'; case es3fUniformApiTests.CheckMethod.RENDER: return 'Verify values by rendering'; default: throw new Error('es3fUniformApiTests.UniformValueCase.getCheckMethodDescription - Invalid check method'); } }; /** * @param {es3fUniformApiTests.AssignMethod} assignMethod * @return {?string} */ es3fUniformApiTests.UniformValueCase.getAssignMethodName = function(assignMethod) { switch (assignMethod) { case es3fUniformApiTests.AssignMethod.POINTER: return 'by_pointer'; case es3fUniformApiTests.AssignMethod.VALUE: return 'by_value'; default: throw new Error('es3fUniformApiTests.UniformValueCase.getAssignMethodName - Invalid assign method'); } }; /** * @param {es3fUniformApiTests.AssignMethod} assignMethod * @return {?string} */ es3fUniformApiTests.UniformValueCase.getAssignMethodDescription = function(assignMethod) { switch (assignMethod) { case es3fUniformApiTests.AssignMethod.POINTER: return 'Assign values by-pointer'; case es3fUniformApiTests.AssignMethod.VALUE: return 'Assign values by-value'; default: throw new Error('es3fUniformApiTests.UniformValueCase.getAssignMethodDescription - Invalid assign method'); } }; /** * es3fUniformApiTests.UniformValueCase test function * @param {Array} basicUniforms * @param {Array} basicUniformReportsRef * @param {gluShaderProgram.ShaderProgram} program * @param {deRandom.Random} rnd * @return {boolean} */ es3fUniformApiTests.UniformValueCase.prototype.test = function(basicUniforms, basicUniformReportsRef, program, rnd) { /** @type {WebGLProgram} */ var programGL = program.getProgram(); if (this.m_valueToCheck == es3fUniformApiTests.ValueToCheck.ASSIGNED) { //TODO: const ScopedLogSection section(log, "UniformAssign", "es3fUniformApiTests.Uniform value assignments"); this.assignUniforms(basicUniforms, programGL, rnd); } else assertMsgOptions( this.m_valueToCheck == es3fUniformApiTests.ValueToCheck.INITIAL, 'es3fUniformApiTests.UniformValueCase.prototype.test - value to check not initial', false, true ); /** @type {boolean}*/ var success; if (this.m_checkMethod == es3fUniformApiTests.CheckMethod.GET_UNIFORM) { /** @type {Array} */ var values = []; //TODO: const ScopedLogSection section(log, "GetUniforms", "es3fUniformApiTests.Uniform value query"); success = this.getUniforms(values, basicUniforms, program.getProgram()); if (!success) return false; if (this.m_valueToCheck == es3fUniformApiTests.ValueToCheck.ASSIGNED) { //TODO: const ScopedLogSection section(log, "ValueCheck", "Verify that the reported values match the assigned values"); success = this.compareUniformValues(values, basicUniforms); if (!success) return false; } else { assertMsgOptions( this.m_valueToCheck == es3fUniformApiTests.ValueToCheck.INITIAL, 'es3fUniformApiTests.UniformValueCase.prototype.test - value to check not initial', false, true ); //TODO: const ScopedLogSection section(log, "ValueCheck", "Verify that the uniforms have correct initial values (zeros)"); success = this.checkUniformDefaultValues(values, basicUniforms); if (!success) return false; } } else { assertMsgOptions( this.m_checkMethod == es3fUniformApiTests.CheckMethod.RENDER, 'es3fUniformApiTests.UniformValueCase.prototype.test - check method different than RENDER', false, true ); //TODO: const ScopedLogSection section(log, "RenderTest", "Render test"); success = this.renderTest(basicUniforms, program, rnd); if (!success) return false; } return true; }; /** * es3fUniformApiTests.RandomUniformCase test class * @constructor * @param {string} name * @param {string} description * @param {number} seed * @extends {es3fUniformApiTests.UniformCase} */ es3fUniformApiTests.RandomUniformCase = function(name, description, seed) { es3fUniformApiTests.UniformCase.call(this, name, description); this.newC(seed ^ deRandom.getBaseSeed()); }; es3fUniformApiTests.RandomUniformCase.prototype = Object.create(es3fUniformApiTests.UniformCase.prototype); /** Constructor restore */ es3fUniformApiTests.RandomUniformCase.prototype.constructor = es3fUniformApiTests.RandomUniformCase; /** * @param {Array} basicUniforms * @param {Array} basicUniformReportsRef * @param {gluShaderProgram.ShaderProgram} program * @param {deRandom.Random} rnd * @return {boolean} */ es3fUniformApiTests.RandomUniformCase.prototype.test = function(basicUniforms, basicUniformReportsRef, program, rnd) { // \note Different sampler types may not be bound to same unit when rendering. /** @type {boolean}*/ var renderingPossible = !this.m_features.UNIFORMVALUE_ZERO || !this.m_uniformCollection.containsSeveralSamplerTypes(); /** @type {boolean} */ var performGetActiveUniforms = rnd.getBool(); /** @type {boolean} */ var performGetActiveUniformsiv = rnd.getBool(); /** @type {boolean} */ var performUniformVsUniformsivComparison = performGetActiveUniforms && performGetActiveUniformsiv && rnd.getBool(); /** @type {boolean} */ var performGetUniforms = rnd.getBool(); /** @type {boolean} */ var performCheckUniformDefaultValues = performGetUniforms && rnd.getBool(); /** @type {boolean} */ var performAssignUniforms = rnd.getBool(); /** @type {boolean} */ var performCompareUniformValues = performGetUniforms && performAssignUniforms && rnd.getBool(); /** @type {boolean} */ var performRenderTest = renderingPossible && performAssignUniforms && rnd.getBool(); /** @type {WebGLProgram} */ var programGL = program.getProgram(); if (!(performGetActiveUniforms || performGetActiveUniformsiv || performUniformVsUniformsivComparison || performGetUniforms || performCheckUniformDefaultValues || performAssignUniforms || performCompareUniformValues || performRenderTest)) performGetActiveUniforms = true; // Do something at least. var PERFORM_AND_CHECK = function(CALL, SECTION_NAME, SECTION_DESCRIPTION) { //TODO: const ScopedLogSection section(log, (SECTION_NAME), (SECTION_DESCRIPTION)); /** @type {boolean} */ var success = CALL(); if (!success) return false; }; /** @type {Array} */ var reportsUniform = []; /** @type {Array} */ var reportsUniformsiv = []; var current = this; //To use "this" in anonymous function. if (performGetActiveUniforms) PERFORM_AND_CHECK(function() {current.getActiveUniformsOneByOne(reportsUniform, basicUniformReportsRef, programGL);}, 'InfoGetActiveUniform', 'es3fUniformApiTests.Uniform information queries with glGetActiveUniform()'); if (performGetActiveUniformsiv) PERFORM_AND_CHECK(function() {current.getActiveUniforms(reportsUniformsiv, basicUniformReportsRef, programGL);}, 'InfoGetActiveUniformsiv', 'es3fUniformApiTests.Uniform information queries with glGetIndices() and glGetActiveUniformsiv()'); if (performUniformVsUniformsivComparison) PERFORM_AND_CHECK(function() {current.uniformVsUniformsComparison(reportsUniform, reportsUniformsiv);}, 'CompareUniformVsUniformsiv', 'Comparison of results from glGetActiveUniform() and glGetActiveUniformsiv()'); /** @type {Array} */ var uniformDefaultValues = []; if (performGetUniforms) PERFORM_AND_CHECK(function() {current.getUniforms(uniformDefaultValues, basicUniforms, programGL);}, 'GetUniformDefaults', 'es3fUniformApiTests.Uniform default value query'); if (performCheckUniformDefaultValues) PERFORM_AND_CHECK(function() {current.checkUniformDefaultValues(uniformDefaultValues, basicUniforms);}, 'DefaultValueCheck', 'Verify that the uniforms have correct initial values (zeros)'); /** @type {Array} */ var uniformValues = []; if (performAssignUniforms) { //TODO: const ScopedLogSection section(log, "UniformAssign", "es3fUniformApiTests.Uniform value assignments"); this.assignUniforms(basicUniforms, programGL, rnd); } if (performCompareUniformValues) { PERFORM_AND_CHECK(function() {current.getUniforms(uniformValues, basicUniforms, programGL);}, 'GetUniforms', 'es3fUniformApiTests.Uniform value query'); PERFORM_AND_CHECK(function() {current.compareUniformValues(uniformValues, basicUniforms);}, 'ValueCheck', 'Verify that the reported values match the assigned values'); } if (performRenderTest) PERFORM_AND_CHECK(function() {current.renderTest(basicUniforms, program, rnd);}, 'RenderTest', 'Render test'); return true; }; /** * Initializes the tests to be performed. */ es3fUniformApiTests.init = function() { var state = tcuTestCase.runner; var testGroup = state.testCases; // Generate sets of UniformCollections that are used by several cases. /** * @enum */ var UniformCollections = { BASIC: 0, BASIC_ARRAY: 1, BASIC_STRUCT: 2, STRUCT_IN_ARRAY: 3, ARRAY_IN_STRUCT: 4, NESTED_STRUCTS_ARRAYS: 5, MULTIPLE_BASIC: 6, MULTIPLE_BASIC_ARRAY: 7, MULTIPLE_NESTED_STRUCTS_ARRAYS: 8 }; /** * @constructor */ var UniformCollectionGroup = function() { /** @type {string} */ this.name = ''; /** @type {Array} */ this.cases = []; }; /** @type {Array} */ var defaultUniformCollections = new Array(Object.keys(UniformCollections).length); /** @type {string} */ var name; //Initialize for (var i = 0; i < defaultUniformCollections.length; i++) defaultUniformCollections[i] = new UniformCollectionGroup(); defaultUniformCollections[UniformCollections.BASIC].name = 'basic'; defaultUniformCollections[UniformCollections.BASIC_ARRAY].name = 'basic_array'; defaultUniformCollections[UniformCollections.BASIC_STRUCT].name = 'basic_struct'; defaultUniformCollections[UniformCollections.STRUCT_IN_ARRAY].name = 'struct_in_array'; defaultUniformCollections[UniformCollections.ARRAY_IN_STRUCT].name = 'array_in_struct'; defaultUniformCollections[UniformCollections.NESTED_STRUCTS_ARRAYS].name = 'nested_structs_arrays'; defaultUniformCollections[UniformCollections.MULTIPLE_BASIC].name = 'multiple_basic'; defaultUniformCollections[UniformCollections.MULTIPLE_BASIC_ARRAY].name = 'multiple_basic_array'; defaultUniformCollections[UniformCollections.MULTIPLE_NESTED_STRUCTS_ARRAYS].name = 'multiple_nested_structs_arrays'; for (var dataTypeNdx = 0; dataTypeNdx < es3fUniformApiTests.s_testDataTypes.length; dataTypeNdx++) { /** @type {gluShaderUtil.DataType} */ var dataType = es3fUniformApiTests.s_testDataTypes[dataTypeNdx]; /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(dataType); defaultUniformCollections[UniformCollections.BASIC].cases.push(new es3fUniformApiTests.UniformCollectionCase(typeName, es3fUniformApiTests.UniformCollection.basic(dataType))); if (gluShaderUtil.isDataTypeScalar(dataType) || (gluShaderUtil.isDataTypeVector(dataType) && gluShaderUtil.getDataTypeScalarSize(dataType) == 4) || dataType == gluShaderUtil.DataType.FLOAT_MAT4 || dataType == gluShaderUtil.DataType.SAMPLER_2D) defaultUniformCollections[UniformCollections.BASIC_ARRAY].cases.push(new es3fUniformApiTests.UniformCollectionCase(typeName, es3fUniformApiTests.UniformCollection.basicArray(dataType))); if (gluShaderUtil.isDataTypeScalar(dataType) || dataType == gluShaderUtil.DataType.FLOAT_MAT4 || dataType == gluShaderUtil.DataType.SAMPLER_2D) { /** @type {gluShaderUtil.DataType} */ var secondDataType; if (gluShaderUtil.isDataTypeScalar(dataType)) secondDataType = gluShaderUtil.getDataTypeVector(dataType, 4); else if (dataType == gluShaderUtil.DataType.FLOAT_MAT4) secondDataType = gluShaderUtil.DataType.FLOAT_MAT2; else if (dataType == gluShaderUtil.DataType.SAMPLER_2D) secondDataType = gluShaderUtil.DataType.SAMPLER_CUBE; assertMsgOptions( secondDataType !== undefined, 'es3fUniformApiTests.init - second data type undefined', false, true ); /** @type {string} */ var secondTypeName = gluShaderUtil.getDataTypeName(secondDataType); name = typeName + '_' + secondTypeName; defaultUniformCollections[UniformCollections.BASIC_STRUCT].cases.push(new es3fUniformApiTests.UniformCollectionCase(name, es3fUniformApiTests.UniformCollection.basicStruct(dataType, secondDataType, false))); defaultUniformCollections[UniformCollections.ARRAY_IN_STRUCT].cases.push(new es3fUniformApiTests.UniformCollectionCase(name, es3fUniformApiTests.UniformCollection.basicStruct(dataType, secondDataType, true))); defaultUniformCollections[UniformCollections.STRUCT_IN_ARRAY].cases.push(new es3fUniformApiTests.UniformCollectionCase(name, es3fUniformApiTests.UniformCollection.structInArray(dataType, secondDataType, false))); defaultUniformCollections[UniformCollections.NESTED_STRUCTS_ARRAYS].cases.push(new es3fUniformApiTests.UniformCollectionCase(name, es3fUniformApiTests.UniformCollection.nestedArraysStructs(dataType, secondDataType))); } } defaultUniformCollections[UniformCollections.MULTIPLE_BASIC].cases.push(new es3fUniformApiTests.UniformCollectionCase(null, es3fUniformApiTests.UniformCollection.multipleBasic())); defaultUniformCollections[UniformCollections.MULTIPLE_BASIC_ARRAY].cases.push(new es3fUniformApiTests.UniformCollectionCase(null, es3fUniformApiTests.UniformCollection.multipleBasicArray())); defaultUniformCollections[UniformCollections.MULTIPLE_NESTED_STRUCTS_ARRAYS].cases.push(new es3fUniformApiTests.UniformCollectionCase(null, es3fUniformApiTests.UniformCollection.multipleNestedArraysStructs())); // Info-query cases (check info returned by e.g. glGetActiveUniforms()). // info_query /** @type {tcuTestCase.DeqpTest} */ var infoQueryGroup = tcuTestCase.newTest('info_query', 'Test uniform info querying functions'); testGroup.addChild(infoQueryGroup); /** @type {UniformCollectionGroup} */ var collectionGroup; /** @type {es3fUniformApiTests.UniformCollectionCase} */ var collectionCase; /** @type {es3fUniformApiTests.UniformCollection} (SharedPtr) */ var uniformCollection; /** @type {es3fUniformApiTests.Feature} */ var features; /** @type {tcuTestCase.DeqpTest} */ var collectionTestGroup; /** @type {string} */ var collName; /** @type {es3fUniformApiTests.CheckMethod} */ var checkMethod; /** @type {tcuTestCase.DeqpTest} */ var checkMethodGroup; /** @type {string} */ var collectionGroupName; /** @type {boolean} */ var containsBooleans; /** @type {boolean} */ var varyBoolApiType; /** @type {number} */ var numBoolVariations; /** @type {es3fUniformApiTests.Feature} */ var booleanTypeFeat; /** @type {string} */ var booleanTypeName; /** @type {tcuTestCase.DeqpTest} */ var unusedUniformsGroup; /** @type {Array} */ var shaderTypes = Object.keys(es3fUniformApiTests.CaseShaderType); for (var caseTypeI in es3fUniformApiTests.CaseType) { /** @type {es3fUniformApiTests.CaseType} */ var caseType = es3fUniformApiTests.CaseType[caseTypeI]; /** @type {tcuTestCase.DeqpTest} */ var caseTypeGroup = tcuTestCase.newTest(es3fUniformApiTests.UniformInfoQueryCase.getCaseTypeName(caseType), es3fUniformApiTests.UniformInfoQueryCase.getCaseTypeDescription(caseType)); infoQueryGroup.addChild(caseTypeGroup); for (var collectionGroupNdx = 0; collectionGroupNdx < Object.keys(UniformCollections).length; collectionGroupNdx++) { var numArrayFirstElemNameCases = caseType == es3fUniformApiTests.CaseType.INDICES_UNIFORMSIV && collectionGroupNdx == UniformCollections.BASIC_ARRAY ? 2 : 1; for (var referToFirstArrayElemWithoutIndexI = 0; referToFirstArrayElemWithoutIndexI < numArrayFirstElemNameCases; referToFirstArrayElemWithoutIndexI++) { collectionGroup = defaultUniformCollections[collectionGroupNdx]; collectionGroupName = collectionGroup.name + (referToFirstArrayElemWithoutIndexI == 0 ? '' : '_first_elem_without_brackets'); collectionTestGroup = tcuTestCase.newTest(collectionGroupName, ''); caseTypeGroup.addChild(collectionTestGroup); for (var collectionNdx = 0; collectionNdx < collectionGroup.cases.length; collectionNdx++) { collectionCase = collectionGroup.cases[collectionNdx]; for (var i = 0; i < shaderTypes.length; i++) { name = collectionCase.namePrefix + es3fUniformApiTests.getCaseShaderTypeName(es3fUniformApiTests.CaseShaderType[shaderTypes[i]]); uniformCollection = collectionCase.uniformCollection; features = new es3fUniformApiTests.Feature(); features.ARRAY_FIRST_ELEM_NAME_NO_INDEX = referToFirstArrayElemWithoutIndexI != 0; collectionTestGroup.addChild(new es3fUniformApiTests.UniformInfoQueryCase(name, '', es3fUniformApiTests.CaseShaderType[shaderTypes[i]], uniformCollection, caseType, features)); } } } } // Info-querying cases when unused uniforms are present. unusedUniformsGroup = tcuTestCase.newTest('unused_uniforms', 'Test with unused uniforms'); caseTypeGroup.addChild(unusedUniformsGroup); collectionGroup = defaultUniformCollections[UniformCollections.ARRAY_IN_STRUCT]; for (var collectionNdx = 0; collectionNdx < collectionGroup.cases.length; collectionNdx++) { collectionCase = collectionGroup.cases[collectionNdx]; collName = collectionCase.namePrefix; uniformCollection = collectionCase.uniformCollection; for (var i = 0; i < shaderTypes.length; i++) { name = collName + es3fUniformApiTests.getCaseShaderTypeName(es3fUniformApiTests.CaseShaderType[shaderTypes[i]]); features = new es3fUniformApiTests.Feature(); features.UNIFORMUSAGE_EVERY_OTHER = true; features.ARRAYUSAGE_ONLY_MIDDLE_INDEX = true; unusedUniformsGroup.addChild(new es3fUniformApiTests.UniformInfoQueryCase(name, '', es3fUniformApiTests.CaseShaderType[shaderTypes[i]], uniformCollection, caseType, features)); } } } // Cases testing uniform values. // Cases checking uniforms' initial values (all must be zeros), with glGetUniform*() or by rendering. /** @type {tcuTestCase.DeqpTest} */ var initialValuesGroup = tcuTestCase.newTest( 'value.' + es3fUniformApiTests.UniformValueCase.getValueToCheckName(es3fUniformApiTests.ValueToCheck.INITIAL), es3fUniformApiTests.UniformValueCase.getValueToCheckDescription(es3fUniformApiTests.ValueToCheck.INITIAL)); testGroup.addChild(initialValuesGroup); for (var checkMethodI in es3fUniformApiTests.CheckMethod) { checkMethod = es3fUniformApiTests.CheckMethod[checkMethodI]; checkMethodGroup = tcuTestCase.newTest(es3fUniformApiTests.UniformValueCase.getCheckMethodName(checkMethod), es3fUniformApiTests.UniformValueCase.getCheckMethodDescription(checkMethod)); initialValuesGroup.addChild(checkMethodGroup); for (var collectionGroupNdx = 0; collectionGroupNdx < Object.keys(UniformCollections).length; collectionGroupNdx++) { collectionGroup = defaultUniformCollections[collectionGroupNdx]; collectionTestGroup = tcuTestCase.newTest(collectionGroup.name, ''); checkMethodGroup.addChild(collectionTestGroup); for (var collectionNdx = 0; collectionNdx < collectionGroup.cases.length; collectionNdx++) { collectionCase = collectionGroup.cases[collectionNdx]; collName = collectionCase.namePrefix; uniformCollection = collectionCase.uniformCollection; containsBooleans = uniformCollection.containsMatchingBasicType(gluShaderUtil.isDataTypeBoolOrBVec); varyBoolApiType = checkMethod == es3fUniformApiTests.CheckMethod.GET_UNIFORM && containsBooleans && (collectionGroupNdx == UniformCollections.BASIC || collectionGroupNdx == UniformCollections.BASIC_ARRAY); numBoolVariations = varyBoolApiType ? 3 : 1; if (checkMethod == es3fUniformApiTests.CheckMethod.RENDER && uniformCollection.containsSeveralSamplerTypes()) continue; // \note Samplers' initial API values (i.e. their texture units) are 0, and no two samplers of different types shall have same unit when rendering. for (var booleanTypeI = 0; booleanTypeI < numBoolVariations; booleanTypeI++) { booleanTypeFeat = new es3fUniformApiTests.Feature(); booleanTypeFeat.BOOLEANAPITYPE_INT = booleanTypeI == 1; booleanTypeFeat.BOOLEANAPITYPE_UINT = booleanTypeI == 2; booleanTypeName = booleanTypeI == 1 ? 'int' : booleanTypeI == 2 ? 'uint' : 'float'; /** @type {string} */ var nameWithApiType = varyBoolApiType ? collName + 'api_' + booleanTypeName + '_' : collName; for (var i = 0; i < shaderTypes.length; i++) { name = nameWithApiType + es3fUniformApiTests.getCaseShaderTypeName(es3fUniformApiTests.CaseShaderType[shaderTypes[i]]); collectionTestGroup.addChild(new es3fUniformApiTests.UniformValueCase(name, '', es3fUniformApiTests.CaseShaderType[shaderTypes[i]], uniformCollection, es3fUniformApiTests.ValueToCheck.INITIAL, checkMethod, null, booleanTypeFeat)); } } } } } // Cases that first assign values to each uniform, then check the values with glGetUniform*() or by rendering. /** @type {tcuTestCase.DeqpTest} */ var assignedValuesGroup = tcuTestCase.newTest( 'value.' + es3fUniformApiTests.UniformValueCase.getValueToCheckName(es3fUniformApiTests.ValueToCheck.ASSIGNED), es3fUniformApiTests.UniformValueCase.getValueToCheckDescription(es3fUniformApiTests.ValueToCheck.ASSIGNED)); testGroup.addChild(assignedValuesGroup); for (var assignMethodI in es3fUniformApiTests.AssignMethod) { /** @type {es3fUniformApiTests.AssignMethod} */ var assignMethod = es3fUniformApiTests.AssignMethod[assignMethodI]; /** @type {tcuTestCase.DeqpTest} */ var assignMethodGroup = tcuTestCase.newTest(es3fUniformApiTests.UniformValueCase.getAssignMethodName(assignMethod), es3fUniformApiTests.UniformValueCase.getAssignMethodDescription(assignMethod)); assignedValuesGroup.addChild(assignMethodGroup); for (var checkMethodI in es3fUniformApiTests.CheckMethod) { checkMethod = es3fUniformApiTests.CheckMethod[checkMethodI]; checkMethodGroup = tcuTestCase.newTest(es3fUniformApiTests.UniformValueCase.getCheckMethodName(checkMethod), es3fUniformApiTests.UniformValueCase.getCheckMethodDescription(checkMethod)); assignMethodGroup.addChild(checkMethodGroup); for (var collectionGroupNdx = 0; collectionGroupNdx < Object.keys(UniformCollections).length; collectionGroupNdx++) { /** @type {number} */ var numArrayFirstElemNameCases = checkMethod == es3fUniformApiTests.CheckMethod.GET_UNIFORM && collectionGroupNdx == UniformCollections.BASIC_ARRAY ? 2 : 1; for (var referToFirstArrayElemWithoutIndexI = 0; referToFirstArrayElemWithoutIndexI < numArrayFirstElemNameCases; referToFirstArrayElemWithoutIndexI++) { collectionGroup = defaultUniformCollections[collectionGroupNdx]; collectionGroupName = collectionGroup.name + (referToFirstArrayElemWithoutIndexI == 0 ? '' : '_first_elem_without_brackets'); collectionTestGroup = tcuTestCase.newTest(collectionGroupName, ''); checkMethodGroup.addChild(collectionTestGroup); for (var collectionNdx = 0; collectionNdx < collectionGroup.cases.length; collectionNdx++) { collectionCase = collectionGroup.cases[collectionNdx]; collName = collectionCase.namePrefix; uniformCollection = collectionCase.uniformCollection; containsBooleans = uniformCollection.containsMatchingBasicType(gluShaderUtil.isDataTypeBoolOrBVec); varyBoolApiType = checkMethod == es3fUniformApiTests.CheckMethod.GET_UNIFORM && containsBooleans && (collectionGroupNdx == UniformCollections.BASIC || collectionGroupNdx == UniformCollections.BASIC_ARRAY); numBoolVariations = varyBoolApiType ? 3 : 1; /** @type {boolean} */ var containsMatrices = uniformCollection.containsMatchingBasicType(gluShaderUtil.isDataTypeMatrix); /** @type {boolean} */ var varyMatrixMode = containsMatrices && (collectionGroupNdx == UniformCollections.BASIC || collectionGroupNdx == UniformCollections.BASIC_ARRAY); /** @type {number} */ var numMatVariations = varyMatrixMode ? 2 : 1; if (containsMatrices && assignMethod != es3fUniformApiTests.AssignMethod.POINTER) continue; for (var booleanTypeI = 0; booleanTypeI < numBoolVariations; booleanTypeI++) { booleanTypeFeat = new es3fUniformApiTests.Feature(); booleanTypeFeat.BOOLEANAPITYPE_INT = booleanTypeI == 1; booleanTypeFeat.BOOLEANAPITYPE_UINT = booleanTypeI == 2; booleanTypeName = booleanTypeI == 1 ? 'int' : booleanTypeI == 2 ? 'uint' : 'float'; /** @type {string} */ var nameWithBoolType = varyBoolApiType ? collName + 'api_' + booleanTypeName + '_' : collName; for (var matrixTypeI = 0; matrixTypeI < numMatVariations; matrixTypeI++) { /** @type {string} */ var nameWithMatrixType = nameWithBoolType + (matrixTypeI == 1 ? 'row_major_' : ''); for (var i = 0; i < shaderTypes.length; i++) { name = nameWithMatrixType + es3fUniformApiTests.getCaseShaderTypeName(es3fUniformApiTests.CaseShaderType[shaderTypes[i]]); booleanTypeFeat.ARRAY_FIRST_ELEM_NAME_NO_INDEX = referToFirstArrayElemWithoutIndexI != 0; booleanTypeFeat.MATRIXMODE_ROWMAJOR = matrixTypeI == 1; collectionTestGroup.addChild(new es3fUniformApiTests.UniformValueCase(name, '', es3fUniformApiTests.CaseShaderType[shaderTypes[i]], uniformCollection, es3fUniformApiTests.ValueToCheck.ASSIGNED, checkMethod, assignMethod, booleanTypeFeat)); } } } } } } } } // Cases assign multiple basic-array elements with one glUniform*v() (i.e. the count parameter is bigger than 1). /** @type {es3fUniformApiTests.Feature} */ var arrayAssignFullMode = new es3fUniformApiTests.Feature(); arrayAssignFullMode.ARRAYASSIGN_FULL = true; /** @type {es3fUniformApiTests.Feature} */ var arrayAssignBlocksOfTwo = new es3fUniformApiTests.Feature(); arrayAssignFullMode.ARRAYASSIGN_BLOCKS_OF_TWO = true; var arrayAssignGroups = [{arrayAssignMode: arrayAssignFullMode, name: 'basic_array_assign_full', description: 'Assign entire basic-type arrays per glUniform*v() call'}, {arrayAssignMode: arrayAssignBlocksOfTwo, name: 'basic_array_assign_partial', description: 'Assign two elements of a basic-type array per glUniform*v() call'} ]; for (var arrayAssignGroupNdx = 0; arrayAssignGroupNdx < arrayAssignGroups.length; arrayAssignGroupNdx++) { /** @type {es3fUniformApiTests.Feature} */ var arrayAssignMode = arrayAssignGroups[arrayAssignGroupNdx].arrayAssignMode; /** @type {string} */ var groupName = arrayAssignGroups[arrayAssignGroupNdx].name; /** @type {string} */ var groupDesc = arrayAssignGroups[arrayAssignGroupNdx].description; /** @type {tcuTestCase.DeqpTest} */ var curArrayAssignGroup = tcuTestCase.newTest(groupName, groupDesc); assignedValuesGroup.addChild(curArrayAssignGroup); /** @type {Array} */ var basicArrayCollectionGroups = [UniformCollections.BASIC_ARRAY, UniformCollections.ARRAY_IN_STRUCT, UniformCollections.MULTIPLE_BASIC_ARRAY]; for (var collectionGroupNdx = 0; collectionGroupNdx < basicArrayCollectionGroups.length; collectionGroupNdx++) { collectionGroup = defaultUniformCollections[basicArrayCollectionGroups[collectionGroupNdx]]; collectionTestGroup = tcuTestCase.newTest(collectionGroup.name, ''); curArrayAssignGroup.addChild(collectionTestGroup); for (var collectionNdx = 0; collectionNdx < collectionGroup.cases.length; collectionNdx++) { collectionCase = collectionGroup.cases[collectionNdx]; collName = collectionCase.namePrefix; uniformCollection = collectionCase.uniformCollection; for (var i = 0; i < shaderTypes.length; i++) { name = collName + es3fUniformApiTests.getCaseShaderTypeName(es3fUniformApiTests.CaseShaderType[shaderTypes[i]]); collectionTestGroup.addChild(new es3fUniformApiTests.UniformValueCase(name, '', es3fUniformApiTests.CaseShaderType[shaderTypes[i]], uniformCollection, es3fUniformApiTests.ValueToCheck.ASSIGNED, es3fUniformApiTests.CheckMethod.GET_UNIFORM, es3fUniformApiTests.AssignMethod.POINTER, arrayAssignMode)); } } } } // Value checking cases when unused uniforms are present. unusedUniformsGroup = tcuTestCase.newTest('unused_uniforms', 'Test with unused uniforms'); assignedValuesGroup.addChild(unusedUniformsGroup); collectionGroup = defaultUniformCollections[UniformCollections.ARRAY_IN_STRUCT]; for (var collectionNdx = 0; collectionNdx < collectionGroup.cases.length; collectionNdx++) { collectionCase = collectionGroup.cases[collectionNdx]; collName = collectionCase.namePrefix; uniformCollection = collectionCase.uniformCollection; for (var i = 0; i < shaderTypes.length; i++) { name = collName + es3fUniformApiTests.getCaseShaderTypeName(es3fUniformApiTests.CaseShaderType[shaderTypes[i]]); features = new es3fUniformApiTests.Feature(); features.ARRAYUSAGE_ONLY_MIDDLE_INDEX = true; features.UNIFORMUSAGE_EVERY_OTHER = true; unusedUniformsGroup.addChild(new es3fUniformApiTests.UniformValueCase(name, '', es3fUniformApiTests.CaseShaderType[shaderTypes[i]], uniformCollection, es3fUniformApiTests.ValueToCheck.ASSIGNED, es3fUniformApiTests.CheckMethod.GET_UNIFORM, es3fUniformApiTests.AssignMethod.POINTER, features)); } } // Random cases. /** @type {number} */ var numRandomCases = 100; /** @type {tcuTestCase.DeqpTest} */ var randomGroup = tcuTestCase.newTest('random', 'Random cases'); testGroup.addChild(randomGroup); for (var ndx = 0; ndx < numRandomCases; ndx++) randomGroup.addChild(new es3fUniformApiTests.RandomUniformCase('' + ndx, '', ndx)); }; /** * Create and execute the test cases * @param {WebGL2RenderingContext} context */ es3fUniformApiTests.run = function(context, range) { gl = context; //Set up Test Root parameters var testName = 'uniform_api'; var testDescription = 'es3fUniformApiTests.Uniform API Tests'; var state = tcuTestCase.runner; state.testName = testName; state.testCases = tcuTestCase.newTest(testName, testDescription, null); //Set up name and description of this test series. setCurrentTestName(testName); description(testDescription); try { //Create test cases es3fUniformApiTests.init(); if (range) state.setRange(range); //Run test cases tcuTestCase.runTestCases(); } catch (err) { testFailedOptions('Failed to es3fUniformApiTests.run tests', false); tcuTestCase.runner.terminate(); } }; });