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

Source code

Revision control

Copy as Markdown

Other Tools

/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
'use strict';
goog.provide('functional.gles3.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();
}
};
});