diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fUniformBlockTests.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fUniformBlockTests.js | 748 |
1 files changed, 748 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fUniformBlockTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fUniformBlockTests.js new file mode 100644 index 0000000000..91a90fdc64 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fUniformBlockTests.js @@ -0,0 +1,748 @@ +/*------------------------------------------------------------------------- + * 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.es3fUniformBlockTests'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.opengl.gluShaderUtil'); +goog.require('modules.shared.glsRandomUniformBlockCase'); +goog.require('modules.shared.glsUniformBlockCase'); + +goog.scope(function() { + + var es3fUniformBlockTests = functional.gles3.es3fUniformBlockTests; + var gluShaderUtil = framework.opengl.gluShaderUtil; + var glsUniformBlockCase = modules.shared.glsUniformBlockCase; + var glsRandomUniformBlockCase = modules.shared.glsRandomUniformBlockCase; + var tcuTestCase = framework.common.tcuTestCase; + var deMath = framework.delibs.debase.deMath; + var deRandom = framework.delibs.debase.deRandom; + + /** + * es3fUniformBlockTests.createRandomCaseGroup + * @param {tcuTestCase.DeqpTest} parentGroup + * @param {string} groupName + * @param {string} description + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} features + * @param {number} numCases + * @param {number} baseSeed + */ + es3fUniformBlockTests.createRandomCaseGroup = function(parentGroup, groupName, description, bufferMode, features, numCases, baseSeed) { + /** @type {tcuTestCase.DeqpTest} */ + var group = tcuTestCase.newTest(groupName, description); + parentGroup.addChild(group); + + baseSeed += deRandom.getBaseSeed(); + + for (var ndx = 0; ndx < numCases; ndx++) + group.addChild(new glsRandomUniformBlockCase.RandomUniformBlockCase('' + ndx, '', bufferMode, features, ndx + baseSeed)); + }; + + /** + * es3fUniformBlockTests.BlockBasicTypeCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {glsUniformBlockCase.VarType} type The type of the block + * @param {number} layoutFlags + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockBasicTypeCase = function(name, description, type, layoutFlags, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK); + /** @type {glsUniformBlockCase.UniformBlock}*/ var block = this.m_interface.allocBlock('Block'); + block.addUniform(new glsUniformBlockCase.Uniform('var', type, 0)); + block.setFlags(layoutFlags); + + if (numInstances > 0) { + block.setArraySize(numInstances); + block.setInstanceName('block'); + } + }; + + es3fUniformBlockTests.BlockBasicTypeCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockBasicTypeCase.prototype.constructor = es3fUniformBlockTests.BlockBasicTypeCase; + + /** + * es3fUniformBlockTests.createBlockBasicTypeCases + * @param {tcuTestCase.DeqpTest} group + * @param {string} name + * @param {glsUniformBlockCase.VarType} type + * @param {number} layoutFlags + * @param {number=} numInstances + */ + es3fUniformBlockTests.createBlockBasicTypeCases = function(group, name, type, layoutFlags, numInstances) { + numInstances = (numInstances === undefined) ? 0 : numInstances; + group.addChild(new es3fUniformBlockTests.BlockBasicTypeCase(name + '_vertex', '', type, layoutFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, numInstances)); + group.addChild(new es3fUniformBlockTests.BlockBasicTypeCase(name + '_fragment', '', type, layoutFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, numInstances)); + + //alert(group.spec[0].m_instance); + if (!(layoutFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + group.addChild(new es3fUniformBlockTests.BlockBasicTypeCase(name + '_both', '', type, layoutFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, numInstances)); + }; + + /** + * es3fUniformBlockTests.BlockSingleStructCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {number} layoutFlags + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockSingleStructCase = function(name, description, layoutFlags, bufferMode, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); + this.m_layoutFlags = layoutFlags; + this.m_numInstances = numInstances; + }; + + es3fUniformBlockTests.BlockSingleStructCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockSingleStructCase.prototype.constructor = es3fUniformBlockTests.BlockSingleStructCase; + + es3fUniformBlockTests.BlockSingleStructCase.prototype.init = function() { + /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S'); + typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); // First member is unused. + typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4)); + typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)); + + /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block'); + block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeStruct(typeS), 0)); + block.setFlags(this.m_layoutFlags); + + if (this.m_numInstances > 0) { + block.setInstanceName('block'); + block.setArraySize(this.m_numInstances); + } + }; + + /** + * es3fUniformBlockTests.BlockSingleStructArrayCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {number} layoutFlags + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockSingleStructArrayCase = function(name, description, layoutFlags, bufferMode, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); + this.m_layoutFlags = layoutFlags; + this.m_numInstances = numInstances; + }; + + es3fUniformBlockTests.BlockSingleStructArrayCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockSingleStructArrayCase.prototype.constructor = es3fUniformBlockTests.BlockSingleStructArrayCase; + + es3fUniformBlockTests.BlockSingleStructArrayCase.prototype.init = function() { + /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S'); + typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); // First member is unused. + typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4)); + typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)); + + /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block'); + block.addUniform(new glsUniformBlockCase.Uniform('u', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_LOW))); + block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeStruct(typeS), 3))); + block.addUniform(new glsUniformBlockCase.Uniform('v', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM))); + block.setFlags(this.m_layoutFlags); + + if (this.m_numInstances > 0) { + block.setInstanceName('block'); + block.setArraySize(this.m_numInstances); + } + }; + + /** + * es3fUniformBlockTests.BlockSingleNestedStructCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {number} layoutFlags + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockSingleNestedStructCase = function(name, description, layoutFlags, bufferMode, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); + this.m_layoutFlags = layoutFlags; + this.m_numInstances = numInstances; + }; + + es3fUniformBlockTests.BlockSingleNestedStructCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockSingleNestedStructCase.prototype.constructor = es3fUniformBlockTests.BlockSingleNestedStructCase; + + es3fUniformBlockTests.BlockSingleNestedStructCase.prototype.init = function() { + /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S'); + typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)); + typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4)); + typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); + + /**@type {glsUniformBlockCase.StructType}*/ var typeT = this.m_interface.allocStruct('T'); + typeT.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM)); + typeT.addMember('b', glsUniformBlockCase.newVarTypeStruct(typeS)); + + /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block'); + block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeStruct(typeS), 0)); + block.addUniform(new glsUniformBlockCase.Uniform('v', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH)); + block.addUniform(new glsUniformBlockCase.Uniform('t', glsUniformBlockCase.newVarTypeStruct(typeT), 0)); + block.addUniform(new glsUniformBlockCase.Uniform('u', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), 0)); + block.setFlags(this.m_layoutFlags); + + if (this.m_numInstances > 0) { + block.setInstanceName('block'); + block.setArraySize(this.m_numInstances); + } + }; + + /** + * es3fUniformBlockTests.BlockSingleNestedStructArrayCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {number} layoutFlags + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockSingleNestedStructArrayCase = function(name, description, layoutFlags, bufferMode, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); + this.m_layoutFlags = layoutFlags; + this.m_numInstances = numInstances; + }; + + es3fUniformBlockTests.BlockSingleNestedStructArrayCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockSingleNestedStructArrayCase.prototype.constructor = es3fUniformBlockTests.BlockSingleNestedStructArrayCase; + + es3fUniformBlockTests.BlockSingleNestedStructArrayCase.prototype.init = function() { + /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S'); + typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)); + typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4)); + typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); + + /**@type {glsUniformBlockCase.StructType}*/ var typeT = this.m_interface.allocStruct('T'); + typeT.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM)); + typeT.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeStruct(typeS), 3)); + + /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block'); + block.addUniform(new glsUniformBlockCase.Uniform('s', glsUniformBlockCase.newVarTypeStruct(typeS), 0)); + block.addUniform(new glsUniformBlockCase.Uniform('v', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH)); + block.addUniform(new glsUniformBlockCase.Uniform('t', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeStruct(typeT), 2), 0)); + block.addUniform(new glsUniformBlockCase.Uniform('u', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), 0)); + block.setFlags(this.m_layoutFlags); + + if (this.m_numInstances > 0) { + block.setInstanceName('block'); + block.setArraySize(this.m_numInstances); + } + }; + + /** + * es3fUniformBlockTests.BlockMultiBasicTypesCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {number} flagsA + * @param {number} flagsB + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockMultiBasicTypesCase = function(name, description, flagsA, flagsB, bufferMode, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); + this.m_flagsA = flagsA; + this.m_flagsB = flagsB; + this.m_numInstances = numInstances; + }; + + es3fUniformBlockTests.BlockMultiBasicTypesCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockMultiBasicTypesCase.prototype.constructor = es3fUniformBlockTests.BlockMultiBasicTypesCase; + + es3fUniformBlockTests.BlockMultiBasicTypesCase.prototype.init = function() { + /** @type {glsUniformBlockCase.UniformBlock} */ var blockA = this.m_interface.allocBlock('BlockA'); + blockA.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH))); + blockA.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH)); + blockA.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM))); + blockA.setInstanceName('blockA'); + blockA.setFlags(this.m_flagsA); + + /** @type {glsUniformBlockCase.UniformBlock} */ var blockB = this.m_interface.allocBlock('BlockB'); + blockB.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM))); + blockB.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_LOW))); + blockB.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), glsUniformBlockCase.UniformFlags.UNUSED_BOTH)); + blockB.addUniform(new glsUniformBlockCase.Uniform('d', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL, 0))); + blockB.setInstanceName('blockB'); + blockB.setFlags(this.m_flagsB); + + if (this.m_numInstances > 0) { + blockA.setArraySize(this.m_numInstances); + blockB.setArraySize(this.m_numInstances); + } + }; + + /** + * es3fUniformBlockTests.BlockMultiNestedStructCase constructor + * @param {string} name The name of the test + * @param {string} description The description of the test + * @param {number} flagsA + * @param {number} flagsB + * @param {glsUniformBlockCase.BufferMode} bufferMode + * @param {number} numInstances + * @constructor + * @extends {glsUniformBlockCase.UniformBlockCase} + */ + es3fUniformBlockTests.BlockMultiNestedStructCase = function(name, description, flagsA, flagsB, bufferMode, numInstances) { + glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); + this.m_flagsA = flagsA; + this.m_flagsB = flagsB; + this.m_numInstances = numInstances; + }; + + es3fUniformBlockTests.BlockMultiNestedStructCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); + es3fUniformBlockTests.BlockMultiNestedStructCase.prototype.constructor = es3fUniformBlockTests.BlockMultiNestedStructCase; + + es3fUniformBlockTests.BlockMultiNestedStructCase.prototype.init = function() { + /**@type {glsUniformBlockCase.StructType}*/ var typeS = this.m_interface.allocStruct('S'); + typeS.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, glsUniformBlockCase.UniformFlags.PRECISION_LOW)); + typeS.addMember('b', glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.INT_VEC2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), 4)); + typeS.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, glsUniformBlockCase.UniformFlags.PRECISION_HIGH)); + + /**@type {glsUniformBlockCase.StructType}*/ var typeT = this.m_interface.allocStruct('T'); + typeT.addMember('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM), glsUniformBlockCase.UniformFlags.UNUSED_BOTH); + typeT.addMember('b', glsUniformBlockCase.newVarTypeStruct(typeS)); + typeT.addMember('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL_VEC4, 0)); + + /** @type {glsUniformBlockCase.UniformBlock} */ var blockA = this.m_interface.allocBlock('BlockA'); + blockA.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT, glsUniformBlockCase.UniformFlags.PRECISION_HIGH))); + blockA.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeStruct(typeS))); + blockA.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.UINT_VEC3, glsUniformBlockCase.UniformFlags.PRECISION_LOW), glsUniformBlockCase.UniformFlags.UNUSED_BOTH)); + blockA.setInstanceName('blockA'); + blockA.setFlags(this.m_flagsA); + + /** @type {glsUniformBlockCase.UniformBlock} */ var blockB = this.m_interface.allocBlock('BlockB'); + blockB.addUniform(new glsUniformBlockCase.Uniform('a', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM))); + blockB.addUniform(new glsUniformBlockCase.Uniform('b', glsUniformBlockCase.newVarTypeStruct(typeT))); + blockB.addUniform(new glsUniformBlockCase.Uniform('c', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL_VEC4, 0), glsUniformBlockCase.UniformFlags.UNUSED_BOTH)); + blockB.addUniform(new glsUniformBlockCase.Uniform('d', glsUniformBlockCase.newVarTypeBasic(gluShaderUtil.DataType.BOOL, 0))); + blockB.setInstanceName('blockB'); + blockB.setFlags(this.m_flagsB); + + if (this.m_numInstances > 0) { + blockA.setArraySize(this.m_numInstances); + blockB.setArraySize(this.m_numInstances); + } + }; + + /** + * Creates the test hierarchy to be executed. + **/ + es3fUniformBlockTests.init = function() { + /** @const @type {tcuTestCase.DeqpTest} */ var testGroup = tcuTestCase.runner.testCases; + + /** @type {Array<gluShaderUtil.DataType>} */ + var basicTypes = [ + gluShaderUtil.DataType.FLOAT, + gluShaderUtil.DataType.FLOAT_VEC2, + gluShaderUtil.DataType.FLOAT_VEC3, + gluShaderUtil.DataType.FLOAT_VEC4, + 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.FLOAT_MAT2, + gluShaderUtil.DataType.FLOAT_MAT3, + gluShaderUtil.DataType.FLOAT_MAT4, + gluShaderUtil.DataType.FLOAT_MAT2X3, + gluShaderUtil.DataType.FLOAT_MAT2X4, + gluShaderUtil.DataType.FLOAT_MAT3X2, + gluShaderUtil.DataType.FLOAT_MAT3X4, + gluShaderUtil.DataType.FLOAT_MAT4X2, + gluShaderUtil.DataType.FLOAT_MAT4X3 + ]; + + /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */ + var precisionFlags = [{ name: 'lowp', flags: glsUniformBlockCase.UniformFlags.PRECISION_LOW }, { name: 'mediump', flags: glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM }, { name: 'highp', flags: glsUniformBlockCase.UniformFlags.PRECISION_HIGH } + ]; + + /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */ + var layoutFlags = [ /* { name: 'shared', flags: glsUniformBlockCase.UniformFlags.LAYOUT_SHARED }, */ + /* { name: 'packed', flags: glsUniformBlockCase.UniformFlags.LAYOUT_PACKED }, */ { name: 'std140', flags: glsUniformBlockCase.UniformFlags.LAYOUT_STD140 } + ]; + + /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */ + var matrixFlags = [{ name: 'row_major', flags: glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR }, { name: 'column_major', flags: glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR } + ]; + + /** @type {Array<Object.<string, glsUniformBlockCase.UniformFlags>>} */ + var bufferModes = [{ name: 'per_block_buffer', mode: glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK }, { name: 'single_buffer', mode: glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE } + ]; + + // ubo.single_basic_type + /** @type {tcuTestCase.DeqpTest} */ + var singleBasicTypeGroup = tcuTestCase.newTest('single_basic_type', 'Single basic variable in single buffer'); + + testGroup.addChild(singleBasicTypeGroup); + + /** @type {tcuTestCase.DeqpTest} */ + var layoutGroup; + /** @type {gluShaderUtil.DataType} */ + var type; + /** @type {string} */ + var typeName; + /** @type {tcuTestCase.DeqpTest} */ + var modeGroup; + /** @type {string} */ + var baseName; + /** @type {number} */ + var baseFlags; + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + + layoutGroup = tcuTestCase.newTest(layoutFlags[layoutFlagNdx].name, '', null); + singleBasicTypeGroup.addChild(layoutGroup); + + for (var basicTypeNdx = 0; basicTypeNdx < basicTypes.length; basicTypeNdx++) { + type = basicTypes[basicTypeNdx]; + typeName = gluShaderUtil.getDataTypeName(type); + + if (gluShaderUtil.isDataTypeBoolOrBVec(type)) + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, typeName, glsUniformBlockCase.newVarTypeBasic(type, 0), layoutFlags[layoutFlagNdx].flags); + else { + for (var precNdx = 0; precNdx < precisionFlags.length; precNdx++) + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, precisionFlags[precNdx].name + '_' + typeName, + glsUniformBlockCase.newVarTypeBasic(type, precisionFlags[precNdx].flags), layoutFlags[layoutFlagNdx].flags); + } + + if (gluShaderUtil.isDataTypeMatrix(type)) { + for (var matFlagNdx = 0; matFlagNdx < matrixFlags.length; matFlagNdx++) { + for (var precNdx = 0; precNdx < precisionFlags.length; precNdx++) + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, matrixFlags[matFlagNdx].name + '_' + precisionFlags[precNdx].name + '_' + typeName, + glsUniformBlockCase.newVarTypeBasic(type, precisionFlags[precNdx].flags), layoutFlags[layoutFlagNdx].flags | matrixFlags[matFlagNdx].flags); + } + } + } + } + bufferedLogToConsole('ubo.single_basic_type: Tests created'); + + // ubo.single_basic_array + /** @type {tcuTestCase.DeqpTest} */ + var singleBasicArrayGroup = tcuTestCase.newTest('single_basic_array', 'Single basic array variable in single buffer'); + testGroup.addChild(singleBasicArrayGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + layoutGroup = tcuTestCase.newTest(layoutFlags[layoutFlagNdx].name, '', null); + singleBasicArrayGroup.addChild(layoutGroup); + + for (var basicTypeNdx = 0; basicTypeNdx < basicTypes.length; basicTypeNdx++) { + type = basicTypes[basicTypeNdx]; + typeName = gluShaderUtil.getDataTypeName(type); + /** @type {number} */ var arraySize = 3; + + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, typeName, + glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(type, gluShaderUtil.isDataTypeBoolOrBVec(type) ? 0 : glsUniformBlockCase.UniformFlags.PRECISION_HIGH), arraySize), + layoutFlags[layoutFlagNdx].flags); + + if (gluShaderUtil.isDataTypeMatrix(type)) { + for (var matFlagNdx = 0; matFlagNdx < matrixFlags.length; matFlagNdx++) + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, matrixFlags[matFlagNdx].name + '_' + typeName, + glsUniformBlockCase.newVarTypeArray(glsUniformBlockCase.newVarTypeBasic(type, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), arraySize), + layoutFlags[layoutFlagNdx].flags | matrixFlags[matFlagNdx].flags); + } + } + } + bufferedLogToConsole('ubo.single_basic_array: Tests created'); + + // ubo.single_struct + /** @type {tcuTestCase.DeqpTest} */ + var singleStructGroup = tcuTestCase.newTest('single_struct', 'Single struct in uniform block'); + testGroup.addChild(singleStructGroup); + + for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) { + modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, ''); + singleStructGroup.addChild(modeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + for (var isArray = 0; isArray < 2; isArray++) { + baseName = layoutFlags[layoutFlagNdx].name; + baseFlags = layoutFlags[layoutFlagNdx].flags; + + if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0) + continue; // Doesn't make sense to add this variant. + + if (isArray) + baseName += '_instance_array'; + + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + } + } + } + bufferedLogToConsole('ubo.single_struct: Tests created'); + + // ubo.single_struct_array + /** @type {tcuTestCase.DeqpTest} */ + var singleStructArrayGroup = tcuTestCase.newTest('single_struct_array', 'Struct array in one uniform block'); + testGroup.addChild(singleStructArrayGroup); + + for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) { + modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, ''); + singleStructArrayGroup.addChild(modeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + for (var isArray = 0; isArray < 2; isArray++) { + baseName = layoutFlags[layoutFlagNdx].name; + baseFlags = layoutFlags[layoutFlagNdx].flags; + + if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0) + continue; // Doesn't make sense to add this variant. + + if (isArray) + baseName += '_instance_array'; + + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructArrayCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructArrayCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleStructArrayCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + } + } + } + bufferedLogToConsole('ubo.single_struct_array: Tests created'); + + // ubo.single_nested_struct + /** @type {tcuTestCase.DeqpTest} */ + var singleNestedStructGroup = tcuTestCase.newTest('single_nested_struct', 'Nested struct in one uniform block'); + testGroup.addChild(singleNestedStructGroup); + + for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) { + modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, ''); + singleNestedStructGroup.addChild(modeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + for (var isArray = 0; isArray < 2; isArray++) { + baseName = layoutFlags[layoutFlagNdx].name; + baseFlags = layoutFlags[layoutFlagNdx].flags; + + if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0) + continue; // Doesn't make sense to add this variant. + + if (isArray) + baseName += '_instance_array'; + + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + } + } + } + bufferedLogToConsole('ubo.single_nested_struct: Tests created'); + + // ubo.single_nested_struct_array + /** @type {tcuTestCase.DeqpTest} */ + var singleNestedStructArrayGroup = tcuTestCase.newTest('single_nested_struct_array', 'Nested struct array in one uniform block'); + testGroup.addChild(singleNestedStructArrayGroup); + + for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) { + modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, ''); + singleNestedStructArrayGroup.addChild(modeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + for (var isArray = 0; isArray < 2; isArray++) { + baseName = layoutFlags[layoutFlagNdx].name; + baseFlags = layoutFlags[layoutFlagNdx].flags; + + if (bufferModes[modeNdx].mode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE && isArray == 0) + continue; // Doesn't make sense to add this variant. + + if (isArray) + baseName += '_instance_array'; + + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructArrayCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructArrayCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + modeGroup.addChild(new es3fUniformBlockTests.BlockSingleNestedStructArrayCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + } + } + } + bufferedLogToConsole('ubo.single_nested_struct_array: Tests created'); + + // ubo.instance_array_basic_type + /** @type {tcuTestCase.DeqpTest} */ + var instanceArrayBasicTypeGroup = tcuTestCase.newTest('instance_array_basic_type', 'Single basic variable in instance array'); + testGroup.addChild(instanceArrayBasicTypeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + layoutGroup = tcuTestCase.newTest(layoutFlags[layoutFlagNdx].name, ''); + instanceArrayBasicTypeGroup.addChild(layoutGroup); + + for (var basicTypeNdx = 0; basicTypeNdx < basicTypes.length; basicTypeNdx++) { + type = basicTypes[basicTypeNdx]; + typeName = gluShaderUtil.getDataTypeName(type); + /** @type {number} */ var numInstances = 3; + + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, typeName, + glsUniformBlockCase.newVarTypeBasic(type, gluShaderUtil.isDataTypeBoolOrBVec(type) ? 0 : glsUniformBlockCase.UniformFlags.PRECISION_HIGH), + layoutFlags[layoutFlagNdx].flags, numInstances); + + if (gluShaderUtil.isDataTypeMatrix(type)) { + for (var matFlagNdx = 0; matFlagNdx < matrixFlags.length; matFlagNdx++) + es3fUniformBlockTests.createBlockBasicTypeCases(layoutGroup, matrixFlags[matFlagNdx].name + '_' + typeName, + glsUniformBlockCase.newVarTypeBasic(type, glsUniformBlockCase.UniformFlags.PRECISION_HIGH), layoutFlags[layoutFlagNdx].flags | matrixFlags[matFlagNdx].flags, + numInstances); + } + } + } + bufferedLogToConsole('ubo.instance_array_basic_type: Tests created'); + + // ubo.multi_basic_types + /** @type {tcuTestCase.DeqpTest} */ + var multiBasicTypesGroup = tcuTestCase.newTest('multi_basic_types', 'Multiple buffers with basic types'); + testGroup.addChild(multiBasicTypesGroup); + + for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) { + modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, ''); + multiBasicTypesGroup.addChild(modeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + for (var isArray = 0; isArray < 2; isArray++) { + baseName = layoutFlags[layoutFlagNdx].name; + baseFlags = layoutFlags[layoutFlagNdx].flags; + + if (isArray) + baseName += '_instance_array'; + + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiBasicTypesCase(baseName + '_mixed', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + } + } + } + bufferedLogToConsole('ubo.multi_basic_types: Tests created'); + + // ubo.multi_nested_struct + /** @type {tcuTestCase.DeqpTest} */ + var multiNestedStructGroup = tcuTestCase.newTest('multi_nested_struct', 'Multiple buffers with basic types'); + testGroup.addChild(multiNestedStructGroup); + + for (var modeNdx = 0; modeNdx < bufferModes.length; modeNdx++) { + modeGroup = tcuTestCase.newTest(bufferModes[modeNdx].name, ''); + multiNestedStructGroup.addChild(modeGroup); + + for (var layoutFlagNdx = 0; layoutFlagNdx < layoutFlags.length; layoutFlagNdx++) { + for (var isArray = 0; isArray < 2; isArray++) { + baseName = layoutFlags[layoutFlagNdx].name; + baseFlags = layoutFlags[layoutFlagNdx].flags; + + if (isArray) + baseName += '_instance_array'; + + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_vertex', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_fragment', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + if (!(baseFlags & glsUniformBlockCase.UniformFlags.LAYOUT_PACKED)) + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_both', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + + modeGroup.addChild(new es3fUniformBlockTests.BlockMultiNestedStructCase(baseName + '_mixed', '', baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_VERTEX, baseFlags | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT, bufferModes[modeNdx].mode, isArray ? 3 : 0)); + } + } + } + bufferedLogToConsole('ubo.multi_nested_struct: Tests created'); + + /* ubo.random */ + /** @type {number} */ var allShaders = glsRandomUniformBlockCase.FeatureBits.FEATURE_VERTEX_BLOCKS | glsRandomUniformBlockCase.FeatureBits.FEATURE_FRAGMENT_BLOCKS | glsRandomUniformBlockCase.FeatureBits.FEATURE_SHARED_BLOCKS; + /** @type {number} */ var allLayouts = glsRandomUniformBlockCase.FeatureBits.FEATURE_STD140_LAYOUT; + /** @type {number} */ var allBasicTypes = glsRandomUniformBlockCase.FeatureBits.FEATURE_VECTORS | glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRICES; + /** @type {number} */ var unused = glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_MEMBERS | glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_UNIFORMS; + /** @type {number} */ var matFlags = glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRIX_LAYOUT; + /** @type {number} */ var allFeatures = (~glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS_OF_ARRAYS & 0xFFFF); + + /** @type {tcuTestCase.DeqpTest} */ + var randomGroup = tcuTestCase.newTest('random', 'Random Uniform Block cases'); + testGroup.addChild(randomGroup); + + // Basic types. + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'scalar_types', 'Scalar types only, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused, 25, 0); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'vector_types', 'Scalar and vector types only, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | glsRandomUniformBlockCase.FeatureBits.FEATURE_VECTORS, 25, 25); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'basic_types', 'All basic types, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags, 25, 50); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'basic_arrays', 'Arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS, 25, 50); + + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'basic_instance_arrays', 'Basic instance arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS, 25, 75); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs', 'Nested structs, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS, 25, 100); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs_arrays', 'Nested structs, arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS | glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS, 25, 150); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs_instance_arrays', 'Nested structs, instance arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS | glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS, 25, 125); + es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'nested_structs_arrays_instance_arrays', 'Nested structs, instance arrays, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allShaders | allLayouts | unused | allBasicTypes | matFlags | glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS | glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS | glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS, 25, 175); + + // Disabled: WebGL does not support shared or packed uniform buffers. + //es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'all_per_block_buffers', 'All random features, per-block buffers', glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK, allFeatures, 50, 200); + //es3fUniformBlockTests.createRandomCaseGroup(randomGroup, 'all_shared_buffer', 'All random features, shared buffer', glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE, allFeatures, 50, 250); + bufferedLogToConsole('ubo.random: Tests created'); + }; + + /** + * Create and execute the test cases + */ + es3fUniformBlockTests.run = function(range) { + //Set up Test Root parameters + var testName = 'ubo'; + var testDescription = 'Uniform Block Tests'; + var state = tcuTestCase.runner; + + state.setRoot(tcuTestCase.newTest(testName, testDescription, null)); + + //Set up name and description of this test series. + setCurrentTestName(testName); + description(testDescription); + + try { + //Create test cases + es3fUniformBlockTests.init(); + if (range) + state.setRange(range); + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + testFailedOptions('Failed to es3fUniformBlockTests.run tests', false); + tcuTestCase.runner.terminate(); + } + }; + +}); |