| /*------------------------------------------------------------------------- |
| * 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<gluShaderUtil.DataType>} */ 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<number>} 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<gluShaderUtil.DataType>} 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<gluVarType.StructType>} 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<number>} */ fillColor: [] |
| }; |
| }; |
| |
| /** |
| * es3fUniformApiTests.VarValue class. may contain different types. |
| * @constructor |
| */ |
| es3fUniformApiTests.VarValue = function() { |
| /** @type {gluShaderUtil.DataType} */ this.type; |
| /** @type {Array<number | boolean> | 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<es3fUniformApiTests.Uniform>} */ this.m_uniforms = []; |
| /** @type {Array<gluVarType.StructType>} */ 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<gluShaderUtil.DataType>} |
| */ |
| es3fUniformApiTests.UniformCollection.prototype.getSamplerTypes = function() { |
| /** @type {Array<gluShaderUtil.DataType>} */ 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<gluShaderUtil.DataType>} */ 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<gluShaderUtil.DataType>} */ 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<gluShaderUtil.DataType>} */ var types0 = [gluShaderUtil.DataType.FLOAT, gluShaderUtil.DataType.INT, gluShaderUtil.DataType.BOOL_VEC4]; |
| /** @type {Array<gluShaderUtil.DataType>} */ 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<gluVarType.StructType>} */ 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<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.BasicUniformReportGL>} 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<gluTexture.Texture2D>} */ this.m_textures2d = []; |
| /** @type {Array<gluTexture.TextureCube>} */ this.m_texturesCube = []; |
| /** @type {Array<number>} */ 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<es3fUniformApiTests.BasicUniform>} basicUniformsDst |
| * @param {Array<es3fUniformApiTests.BasicUniformReportRef>} 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<boolean>} */ 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<gluShaderUtil.DataType>} */ var samplerTypes = this.m_uniformCollection.getSamplerTypes(); |
| |
| for (var compFuncNdx = 0; compFuncNdx < compareFuncs.length; compFuncNdx++) { |
| /** @type {Array<es3fUniformApiTests.dataTypePredicate>} */ 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<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.BasicUniform>} 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<number>} */ 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<es3fUniformApiTests.BasicUniformReportGL>} basicUniformReportsDst |
| * @param {Array<es3fUniformApiTests.BasicUniformReportRef>} 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<es3fUniformApiTests.BasicUniformReportGL>} basicUniformReportsDst |
| * @param {Array<es3fUniformApiTests.BasicUniformReportRef>} basicUniformReportsRef |
| * @param {WebGLProgram} programGL |
| * @return {boolean} |
| */ |
| es3fUniformApiTests.UniformCase.prototype.getActiveUniforms = function(basicUniformReportsDst, basicUniformReportsRef, programGL) { |
| /** @type {Array<string>} */ var queryNames = new Array(basicUniformReportsRef.length); |
| /** @type {Array<string>} */ var queryNamesC = new Array(basicUniformReportsRef.length); |
| /** @type {Array<number>} (GLuint) */ var uniformIndices = new Array(basicUniformReportsRef.length); |
| /** @type {Array<number>} */ 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<string>} */ var uniformNameBuf = new Array(validUniformIndices.length); |
| /** @type {Array<number>} (GLint) */ var uniformSizeBuf = new Array(validUniformIndices.length); |
| /** @type {Array<number>} (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<es3fUniformApiTests.BasicUniformReportGL>} uniformResults |
| * @param {Array<es3fUniformApiTests.BasicUniformReportGL>} 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<es3fUniformApiTests.VarValue>} valuesDst |
| * @param {Array<es3fUniformApiTests.BasicUniform>} 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<number>} */ (result.length === undefined ? [result] : result); |
| |
| valuesDst.push(value); |
| |
| bufferedLogToConsole('// Got ' + uniform.name + ' value ' + es3fUniformApiTests.apiVarValueStr(value)); |
| } |
| |
| return success; |
| }; |
| |
| /** |
| * @param {Array<es3fUniformApiTests.VarValue>} values |
| * @param {Array<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.VarValue>} */ var valuesToAssign = []; |
| /** @type {Array<number>} */ 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<number>} */ (uniform.finalValue.val); |
| gl.uniform1iv(location, unit); |
| } |
| } else |
| throw new Error('es3fUniformApiTests.UniformCase.prototype.assignUniforms - Invalid uniform type'); |
| } |
| }; |
| |
| /** |
| * @param {Array<es3fUniformApiTests.VarValue>} values |
| * @param {Array<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.BasicUniform>} 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<es3fUniformApiTests.BasicUniform>} */ var basicUniforms = []; |
| /** @type {Array<es3fUniformApiTests.BasicUniformReportRef>} */ 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<es3fUniformApiTests.BasicUniform>} basicUniforms |
| * @param {Array<es3fUniformApiTests.BasicUniformReportRef>} 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<es3fUniformApiTests.BasicUniformReportGL>} */ var basicUniformReportsUniform = []; |
| /** @type {Array<es3fUniformApiTests.BasicUniformReportGL>} */ 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<es3fUniformApiTests.BasicUniform>} basicUniforms |
| * @param {Array<es3fUniformApiTests.BasicUniformReportRef>} 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<es3fUniformApiTests.VarValue>} */ 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<es3fUniformApiTests.BasicUniform>} basicUniforms |
| * @param {Array<es3fUniformApiTests.BasicUniformReportRef>} 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<es3fUniformApiTests.BasicUniformReportGL>} */ var reportsUniform = []; |
| /** @type {Array<es3fUniformApiTests.BasicUniformReportGL>} */ 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<es3fUniformApiTests.VarValue>} */ 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<es3fUniformApiTests.VarValue>} */ 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<es3fUniformApiTests.UniformCollectionCase>} */ this.cases = []; |
| }; |
| |
| /** @type {Array<UniformCollectionGroup>} */ 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<string>} */ 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<number>} */ 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(); |
| } |
| }; |
| |
| }); |