| /*------------------------------------------------------------------------- |
| * 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('modules.shared.glsRandomUniformBlockCase'); |
| 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.glsUniformBlockCase'); |
| |
| goog.scope(function() { |
| |
| var glsRandomUniformBlockCase = modules.shared.glsRandomUniformBlockCase; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| var glsUniformBlockCase = modules.shared.glsUniformBlockCase; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var deMath = framework.delibs.debase.deMath; |
| var deRandom = framework.delibs.debase.deRandom; |
| |
| glsRandomUniformBlockCase.FeatureBits = { |
| FEATURE_VECTORS: (1 << 0), |
| FEATURE_MATRICES: (1 << 1), |
| FEATURE_ARRAYS: (1 << 2), |
| FEATURE_STRUCTS: (1 << 3), |
| FEATURE_NESTED_STRUCTS: (1 << 4), |
| FEATURE_INSTANCE_ARRAYS: (1 << 5), |
| FEATURE_VERTEX_BLOCKS: (1 << 6), |
| FEATURE_FRAGMENT_BLOCKS: (1 << 7), |
| FEATURE_SHARED_BLOCKS: (1 << 8), |
| FEATURE_UNUSED_UNIFORMS: (1 << 9), |
| FEATURE_UNUSED_MEMBERS: (1 << 10), |
| FEATURE_PACKED_LAYOUT: (1 << 11), |
| FEATURE_SHARED_LAYOUT: (1 << 12), |
| FEATURE_STD140_LAYOUT: (1 << 13), |
| FEATURE_MATRIX_LAYOUT: (1 << 14), //!< Matrix layout flags. |
| FEATURE_ARRAYS_OF_ARRAYS: (1 << 15) |
| }; |
| |
| /** |
| * glsRandomUniformBlockCase.RandomUniformBlockCase class |
| * @param {string} name |
| * @param {string} description |
| * @param {glsUniformBlockCase.BufferMode} bufferMode |
| * @param {number} features |
| * @param {number} seed |
| * @constructor |
| * @extends {glsUniformBlockCase.UniformBlockCase} |
| */ |
| glsRandomUniformBlockCase.RandomUniformBlockCase = function(name, description, bufferMode, features, seed) { |
| glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode); |
| this.m_features = features; |
| this.m_maxVertexBlocks = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_VERTEX_BLOCKS) ? 4 : 0); |
| this.m_maxFragmentBlocks = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_FRAGMENT_BLOCKS) ? 4 : 0); |
| this.m_maxSharedBlocks = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_SHARED_BLOCKS) ? 4 : 0); |
| this.m_maxInstances = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS) ? 3 : 0); |
| this.m_maxArrayLength = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS) ? 8 : 0); |
| this.m_maxStructDepth = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS) ? 2 : 0); |
| this.m_maxBlockMembers = 5; |
| this.m_maxStructMembers = 4; |
| this.m_seed = seed; |
| this.m_blockNdx = 1; |
| this.m_uniformNdx = 1; |
| this.m_structNdx = 1; |
| }; |
| |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype); |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.constructor = glsRandomUniformBlockCase.RandomUniformBlockCase; |
| |
| /** |
| * generateType |
| * @param {deRandom.Random} rnd |
| * @param {number} typeDepth |
| * @param {boolean} arrayOk |
| * @return {glsUniformBlockCase.VarType} |
| */ |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.generateType = function(rnd, typeDepth, arrayOk) { |
| /** @type {number} */ var structWeight = 0.1; |
| /** @type {number} */ var arrayWeight = 0.1; |
| /** @type {number} */ var flags; |
| |
| if (typeDepth < this.m_maxStructDepth && rnd.getFloat() < structWeight) { |
| /** @type {number} */ var unusedVtxWeight = 0.15; |
| /** @type {number} */ var unusedFragWeight = 0.15; |
| /** @type {boolean} */ var unusedOk = (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_MEMBERS) != 0; |
| /** @type {Array<glsUniformBlockCase.VarType>} */ var memberTypes = []; |
| /** @type {number} */ var numMembers = rnd.getInt(1, this.m_maxStructMembers); |
| |
| // Generate members first so nested struct declarations are in correct order. |
| for (var ndx = 0; ndx < numMembers; ndx++) |
| memberTypes.push(this.generateType(rnd, typeDepth + 1, true)); |
| |
| /** @type {glsUniformBlockCase.StructType} */ var structType = this.m_interface.allocStruct('s' + this.genName('A'.charCodeAt(0), 'Z'.charCodeAt(0), this.m_structNdx)); |
| this.m_structNdx += 1; |
| |
| assertMsgOptions(this.m_blockNdx <= 'Z'.charCodeAt(0) - 'A'.charCodeAt(0), 'generateType', false, true); |
| for (var ndx = 0; ndx < numMembers; ndx++) { |
| flags = 0; |
| |
| flags |= (unusedOk && rnd.getFloat() < unusedVtxWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_VERTEX : 0; |
| flags |= (unusedOk && rnd.getFloat() < unusedFragWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT : 0; |
| |
| structType.addMember('m' + ('A'.charCodeAt(0) + ndx), memberTypes[ndx], flags); |
| } |
| |
| return glsUniformBlockCase.newVarTypeStruct(structType); |
| } else if (this.m_maxArrayLength > 0 && arrayOk && rnd.getFloat() < arrayWeight) { |
| /** @type {boolean} */ var arraysOfArraysOk = (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS_OF_ARRAYS) != 0; |
| /** @type {number} */ var arrayLength = rnd.getInt(1, this.m_maxArrayLength); |
| /** @type {glsUniformBlockCase.VarType} */ var elementType = this.generateType(rnd, typeDepth, arraysOfArraysOk); |
| return glsUniformBlockCase.newVarTypeArray(elementType, arrayLength); |
| } else { |
| /** @type {Array<gluShaderUtil.DataType>} */ var typeCandidates = []; |
| |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT); |
| typeCandidates.push(gluShaderUtil.DataType.INT); |
| typeCandidates.push(gluShaderUtil.DataType.UINT); |
| typeCandidates.push(gluShaderUtil.DataType.BOOL); |
| |
| if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_VECTORS) { |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_VEC2); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_VEC3); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_VEC4); |
| typeCandidates.push(gluShaderUtil.DataType.INT_VEC2); |
| typeCandidates.push(gluShaderUtil.DataType.INT_VEC3); |
| typeCandidates.push(gluShaderUtil.DataType.INT_VEC4); |
| typeCandidates.push(gluShaderUtil.DataType.UINT_VEC2); |
| typeCandidates.push(gluShaderUtil.DataType.UINT_VEC3); |
| typeCandidates.push(gluShaderUtil.DataType.UINT_VEC4); |
| typeCandidates.push(gluShaderUtil.DataType.BOOL_VEC2); |
| typeCandidates.push(gluShaderUtil.DataType.BOOL_VEC3); |
| typeCandidates.push(gluShaderUtil.DataType.BOOL_VEC4); |
| } |
| |
| if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRICES) { |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT2); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT2X3); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT3X2); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT3); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT3X4); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT4X2); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT4X3); |
| typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT4); |
| } |
| |
| /** @type {gluShaderUtil.DataType} */ var type = (rnd.choose(typeCandidates)[0]); |
| flags = 0; |
| |
| if (!gluShaderUtil.isDataTypeBoolOrBVec(type)) { |
| // Precision. |
| /** @type {Array<number>} */ var precisionCandidates = [glsUniformBlockCase.UniformFlags.PRECISION_LOW, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM, glsUniformBlockCase.UniformFlags.PRECISION_HIGH]; |
| flags |= rnd.choose(precisionCandidates)[0]; |
| } |
| |
| return glsUniformBlockCase.newVarTypeBasic(type, flags); |
| } |
| }; |
| |
| /** |
| * genName |
| * @param {number} first |
| * @param {number} last |
| * @param {number} ndx |
| * @return {string} |
| */ |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.genName = function(first, last, ndx) { |
| /** @type {string} */ var str = ''; |
| /** @type {number} */ var alphabetLen = last - first + 1; |
| |
| while (ndx > alphabetLen) { |
| str = String.fromCharCode(first + ((ndx - 1) % alphabetLen)) + str; |
| ndx = Math.floor((ndx - 1) / alphabetLen); |
| } |
| |
| str = String.fromCharCode(first + (ndx % (alphabetLen + 1)) - 1) + str; |
| |
| return str; |
| }; |
| |
| /** |
| * generateUniform |
| * @param {deRandom.Random} rnd |
| * @param {glsUniformBlockCase.UniformBlock} block |
| */ |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.generateUniform = function(rnd, block) { |
| /** @type {number} */ var unusedVtxWeight = 0.15; |
| /** @type {number} */ var unusedFragWeight = 0.15; |
| /** @type {boolean} */ var unusedOk = (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_UNIFORMS) != 0; |
| /** @type {number} */ var flags = 0; |
| /** @type {string} */ var name = this.genName('a'.charCodeAt(0), 'z'.charCodeAt(0), this.m_uniformNdx); |
| /** @type {glsUniformBlockCase.VarType} */ var type = this.generateType(rnd, 0, true); //TODO: implement this. |
| |
| flags |= (unusedOk && rnd.getFloat() < unusedVtxWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_VERTEX : 0; |
| flags |= (unusedOk && rnd.getFloat() < unusedFragWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT : 0; |
| |
| block.addUniform(new glsUniformBlockCase.Uniform(name, type, flags)); |
| |
| this.m_uniformNdx += 1; |
| }; |
| |
| /** |
| * generateBlock |
| * @param {deRandom.Random} rnd |
| * @param {number} layoutFlags |
| */ |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.generateBlock = function(rnd, layoutFlags) { |
| assertMsgOptions(this.m_blockNdx <= 'z'.charCodeAt(0) - 'a'.charCodeAt(0), 'generateBlock', false, true); |
| |
| /** @type {number} */ var instanceArrayWeight = 0.3; |
| /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block' + String.fromCharCode('A'.charCodeAt(0) + this.m_blockNdx)); |
| /** @type {number} */ var numInstances = (this.m_maxInstances > 0 && rnd.getFloat() < instanceArrayWeight) ? rnd.getInt(0, this.m_maxInstances) : 0; |
| /** @type {number} */ var numUniforms = rnd.getInt(1, this.m_maxBlockMembers); |
| |
| if (numInstances > 0) |
| block.setArraySize(numInstances); |
| |
| if (numInstances > 0 || rnd.getBool()) |
| block.setInstanceName('block' + String.fromCharCode('A'.charCodeAt(0) + this.m_blockNdx)); |
| |
| // Layout flag candidates. |
| /** @type {Array<number>} */ var layoutFlagCandidates = []; |
| layoutFlagCandidates.push(0); |
| if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_PACKED_LAYOUT) |
| layoutFlagCandidates.push(glsUniformBlockCase.UniformFlags.LAYOUT_SHARED); |
| if ((this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_SHARED_LAYOUT) && ((layoutFlags & glsUniformBlockCase.UniformFlags.DECLARE_BOTH) != glsUniformBlockCase.UniformFlags.DECLARE_BOTH)) |
| layoutFlagCandidates.push(glsUniformBlockCase.UniformFlags.LAYOUT_PACKED); // \note packed layout can only be used in a single shader stage. |
| if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_STD140_LAYOUT) |
| layoutFlagCandidates.push(glsUniformBlockCase.UniformFlags.LAYOUT_STD140); |
| |
| layoutFlags |= rnd.choose(layoutFlagCandidates)[0]; //In Javascript, this function returns an array, so taking element 0. |
| |
| if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRIX_LAYOUT) { |
| /** @type {Array<number>}*/ var matrixCandidates = [0, glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR, glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR]; |
| layoutFlags |= rnd.choose(matrixCandidates)[0]; |
| } |
| |
| block.setFlags(layoutFlags); |
| |
| for (var ndx = 0; ndx < numUniforms; ndx++) |
| this.generateUniform(rnd, block); |
| |
| this.m_blockNdx += 1; |
| }; |
| |
| /** |
| * Initializes the glsRandomUniformBlockCase.RandomUniformBlockCase |
| */ |
| glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.init = function() { |
| /** @type {deRandom.Random} */ var rnd = new deRandom.Random(this.m_seed); |
| |
| /** @type {number} */ var numShared = this.m_maxSharedBlocks > 0 ? rnd.getInt(1, this.m_maxSharedBlocks) : 0; |
| /** @type {number} */ var numVtxBlocks = this.m_maxVertexBlocks - numShared > 0 ? rnd.getInt(1, this.m_maxVertexBlocks - numShared) : 0; |
| /** @type {number} */ var numFragBlocks = this.m_maxFragmentBlocks - numShared > 0 ? rnd.getInt(1, this.m_maxFragmentBlocks - numShared) : 0; |
| |
| for (var ndx = 0; ndx < numShared; ndx++) |
| this.generateBlock(rnd, glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT); |
| |
| for (var ndx = 0; ndx < numVtxBlocks; ndx++) |
| this.generateBlock(rnd, glsUniformBlockCase.UniformFlags.DECLARE_VERTEX); |
| |
| for (var ndx = 0; ndx < numFragBlocks; ndx++) |
| this.generateBlock(rnd, glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT); |
| }; |
| |
| }); |
