diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/canvas/test/webgl-conf/checkout/deqp/modules/shared/glsRandomUniformBlockCase.js | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/modules/shared/glsRandomUniformBlockCase.js')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/modules/shared/glsRandomUniformBlockCase.js | 282 |
1 files changed, 282 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/modules/shared/glsRandomUniformBlockCase.js b/dom/canvas/test/webgl-conf/checkout/deqp/modules/shared/glsRandomUniformBlockCase.js new file mode 100644 index 0000000000..20b8dcd472 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/modules/shared/glsRandomUniformBlockCase.js @@ -0,0 +1,282 @@ +/*------------------------------------------------------------------------- + * 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); + }; + +}); |