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('modules.shared.glsUniformBlockCase');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('framework.delibs.debase.deUtil');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');
goog.scope(function() {
var glsUniformBlockCase = modules.shared.glsUniformBlockCase;
var tcuTestCase = framework.common.tcuTestCase;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluDrawUtil = framework.opengl.gluDrawUtil;
var deUtil = framework.delibs.debase.deUtil;
var deMath = framework.delibs.debase.deMath;
var deRandom = framework.delibs.debase.deRandom;
var deString = framework.delibs.debase.deString;
var DE_ASSERT = function(x) {
if (!x)
throw new Error('Assert failed');
};
var littleEndian = (function() {
var buffer = new ArrayBuffer(2);
new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
// Int16Array uses the platform's endianness.
return new Int16Array(buffer)[0] === 256;
})();
/**
* Class to implement some pointers functionality.
* @constructor
*/
glsUniformBlockCase.BlockPointers = function() {
/** @type {ArrayBuffer} */ this.data; //!< Data (vector<deUint8>).
/** @type {Array<number>} */ this.offsets = []; //!< Reference block pointers (map<int, void*>).
/** @type {Array<number>} */ this.sizes = [];
};
/**
* push - Adds an offset/size pair to the collection
* @param {number} offset Offset of the element to refer.
* @param {number} size Size of the referred element.
*/
glsUniformBlockCase.BlockPointers.prototype.push = function(offset, size) {
this.offsets.push(offset);
this.sizes.push(size);
};
/**
* find - Finds and maps the data at the given offset, and returns a Uint8Array
* @param {number} index of the element to find.
* @return {Uint8Array}
*/
glsUniformBlockCase.BlockPointers.prototype.find = function(index) {
return new Uint8Array(this.data, this.offsets[index], this.sizes[index]);
};
/**
* resize - Replaces resize of a vector in C++. Sets the size of the data buffer.
* NOTE: In this case however, if you resize, the data is lost.
* @param {number} newsize The new size of the data buffer.
*/
glsUniformBlockCase.BlockPointers.prototype.resize = function(newsize) {
this.data = new ArrayBuffer(newsize);
};
/**
* glsUniformBlockCase.isSupportedGLSLVersion
* @param {gluShaderUtil.GLSLVersion} version
* @return {boolean}
*/
glsUniformBlockCase.isSupportedGLSLVersion = function(version) {
return version >= gluShaderUtil.GLSLVersion.V300_ES;
};
/**
* @enum {number}
*/
glsUniformBlockCase.UniformFlags = {
PRECISION_LOW: (1 << 0),
PRECISION_MEDIUM: (1 << 1),
PRECISION_HIGH: (1 << 2),
LAYOUT_SHARED: (1 << 3),
LAYOUT_PACKED: (1 << 4),
LAYOUT_STD140: (1 << 5),
LAYOUT_ROW_MAJOR: (1 << 6),
LAYOUT_COLUMN_MAJOR: (1 << 7), //!< \note Lack of both flags means column-major matrix.
DECLARE_VERTEX: (1 << 8),
DECLARE_FRAGMENT: (1 << 9),
UNUSED_VERTEX: (1 << 10), //!< glsUniformBlockCase.Uniform or struct member is not read in vertex shader.
UNUSED_FRAGMENT: (1 << 11) //!< glsUniformBlockCase.Uniform or struct member is not read in fragment shader.
};
/** @const */ glsUniformBlockCase.UniformFlags.PRECISION_MASK = glsUniformBlockCase.UniformFlags.PRECISION_LOW | glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM | glsUniformBlockCase.UniformFlags.PRECISION_HIGH;
/** @const */ glsUniformBlockCase.UniformFlags.LAYOUT_MASK = glsUniformBlockCase.UniformFlags.LAYOUT_SHARED | glsUniformBlockCase.UniformFlags.LAYOUT_PACKED | glsUniformBlockCase.UniformFlags.LAYOUT_STD140 | glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR | glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR;
/** @const */ glsUniformBlockCase.UniformFlags.DECLARE_BOTH = glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT;
/** @const */ glsUniformBlockCase.UniformFlags.UNUSED_BOTH = glsUniformBlockCase.UniformFlags.UNUSED_VERTEX | glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT;
/**
* glsUniformBlockCase.VarType types enum
* @enum {number}
*/
glsUniformBlockCase.Type = {
TYPE_BASIC: 0,
TYPE_ARRAY: 1,
TYPE_STRUCT: 2
};
glsUniformBlockCase.Type.TYPE_LAST = Object.keys(glsUniformBlockCase.Type).length;
/**
* glsUniformBlockCase.TypeArray struct (nothing to do with JS's TypedArrays)
* @param {glsUniformBlockCase.VarType} elementType
* @param {number} arraySize
* @constructor
*/
glsUniformBlockCase.TypeArray = function(elementType, arraySize) {
/** @type {glsUniformBlockCase.VarType} */ this.elementType = elementType;
/** @type {number} */ this.size = arraySize;
};
/**
* glsUniformBlockCase.VarType class
* @constructor
*/
glsUniformBlockCase.VarType = function() {
/** @type {glsUniformBlockCase.Type} */ this.m_type;
/** @type {number} */ this.m_flags = 0;
/*
* m_data used to be a 'Data' union in C++. Using a var is enough here.
* it will contain any necessary value.
*/
/** @type {(gluShaderUtil.DataType|glsUniformBlockCase.TypeArray|glsUniformBlockCase.StructType)} */
this.m_data;
};
/**
* Creates a basic type glsUniformBlockCase.VarType. Use this after the constructor call.
* @param {gluShaderUtil.DataType} basicType
* @param {number} flags
* @return {glsUniformBlockCase.VarType} The currently modified object
*/
glsUniformBlockCase.VarType.prototype.VarTypeBasic = function(basicType, flags) {
this.m_type = glsUniformBlockCase.Type.TYPE_BASIC;
this.m_flags = flags;
this.m_data = basicType;
return this;
};
/**
* Creates an array type glsUniformBlockCase.VarType. Use this after the constructor call.
* @param {glsUniformBlockCase.VarType} elementType
* @param {number} arraySize
* @return {glsUniformBlockCase.VarType} The currently modified object
*/
glsUniformBlockCase.VarType.prototype.VarTypeArray = function(elementType, arraySize) {
this.m_type = glsUniformBlockCase.Type.TYPE_ARRAY;
this.m_flags = 0;
this.m_data = new glsUniformBlockCase.TypeArray(elementType, arraySize);
return this;
};
/**
* Creates a struct type glsUniformBlockCase.VarType. Use this after the constructor call.
* @param {glsUniformBlockCase.StructType} structPtr
* @return {glsUniformBlockCase.VarType} The currently modified object
*/
glsUniformBlockCase.VarType.prototype.VarTypeStruct = function(structPtr) {
this.m_type = glsUniformBlockCase.Type.TYPE_STRUCT;
this.m_flags = 0;
this.m_data = structPtr;
return this;
};
/** isBasicType
* @return {boolean} true if the glsUniformBlockCase.VarType represents a basic type.
**/
glsUniformBlockCase.VarType.prototype.isBasicType = function() {
return this.m_type == glsUniformBlockCase.Type.TYPE_BASIC;
};
/** isArrayType
* @return {boolean} true if the glsUniformBlockCase.VarType represents an array.
**/
glsUniformBlockCase.VarType.prototype.isArrayType = function() {
return this.m_type == glsUniformBlockCase.Type.TYPE_ARRAY;
};
/** isStructType
* @return {boolean} true if the glsUniformBlockCase.VarType represents a struct.
**/
glsUniformBlockCase.VarType.prototype.isStructType = function() {
return this.m_type == glsUniformBlockCase.Type.TYPE_STRUCT;
};
/** getFlags
* @return {number} returns the flags of the glsUniformBlockCase.VarType.
**/
glsUniformBlockCase.VarType.prototype.getFlags = function() {
return this.m_flags;
};
/** getBasicType
* @return {gluShaderUtil.DataType} returns the basic data type of the glsUniformBlockCase.VarType.
**/
glsUniformBlockCase.VarType.prototype.getBasicType = function() {
return /** @type {gluShaderUtil.DataType} */ (this.m_data);
};
/** getElementType
* @return {glsUniformBlockCase.VarType} returns the glsUniformBlockCase.VarType of the element in case of an Array.
**/
glsUniformBlockCase.VarType.prototype.getElementType = function() {
return this.m_data.elementType;
};
/** getArraySize
* (not to be confused with a javascript array)
* @return {number} returns the size of the array in case it is an array.
**/
glsUniformBlockCase.VarType.prototype.getArraySize = function() {
return this.m_data.size;
};
/** getStruct
* @return {glsUniformBlockCase.StructType} returns the structure when it is a glsUniformBlockCase.StructType.
**/
glsUniformBlockCase.VarType.prototype.getStruct = function() {
return /** @type {glsUniformBlockCase.StructType} */ (this.m_data);
};
/**
* Creates a basic type glsUniformBlockCase.VarType.
* @param {gluShaderUtil.DataType} basicType
* @param {number} flags
* @return {glsUniformBlockCase.VarType}
*/
glsUniformBlockCase.newVarTypeBasic = function(basicType, flags) {
return new glsUniformBlockCase.VarType().VarTypeBasic(basicType, flags);
};
/**
* Creates an array type glsUniformBlockCase.VarType.
* @param {glsUniformBlockCase.VarType} elementType
* @param {number} arraySize
* @return {glsUniformBlockCase.VarType}
*/
glsUniformBlockCase.newVarTypeArray = function(elementType, arraySize) {
return new glsUniformBlockCase.VarType().VarTypeArray(elementType, arraySize);
};
/**
* Creates a struct type glsUniformBlockCase.VarType.
* @param {glsUniformBlockCase.StructType} structPtr
* @return {glsUniformBlockCase.VarType}
*/
glsUniformBlockCase.newVarTypeStruct = function(structPtr) {
return new glsUniformBlockCase.VarType().VarTypeStruct(structPtr);
};
/** glsUniformBlockCase.StructMember
* in the JSDoc annotations or if a number would do.
* @constructor
**/
glsUniformBlockCase.StructMember = function() {
/** @type {string} */ this.m_name;
/** @type {glsUniformBlockCase.VarType} */ this.m_type;
/** @type {number} */ this.m_flags = 0;
};
/**
* Creates a glsUniformBlockCase.StructMember. Use this after the constructor call.
* @param {string} name
* @param {glsUniformBlockCase.VarType} type
* @param {number} flags
* @return {glsUniformBlockCase.StructMember} The currently modified object
*/
glsUniformBlockCase.StructMember.prototype.Constructor = function(name, type, flags) {
this.m_type = type;
this.m_name = name;
this.m_flags = flags;
return this;
};
/** getName
* @return {string} the name of the member
**/
glsUniformBlockCase.StructMember.prototype.getName = function() { return this.m_name; };
/** getType
* @return {glsUniformBlockCase.VarType} the type of the member
**/
glsUniformBlockCase.StructMember.prototype.getType = function() { return this.m_type; };
/** getFlags
* @return {number} the flags in the member
**/
glsUniformBlockCase.StructMember.prototype.getFlags = function() { return this.m_flags; };
/**
* Creates a glsUniformBlockCase.StructMember with name, type and flags.
* @param {string} name
* @param {glsUniformBlockCase.VarType} type
* @return {glsUniformBlockCase.StructMember}
*/
glsUniformBlockCase.newStructMember = function(name, type, flags) {
return new glsUniformBlockCase.StructMember().Constructor(name, type, flags);
};
/**
* glsUniformBlockCase.StructType
* @constructor
*/
glsUniformBlockCase.StructType = function() {
/** @type {string}*/ this.m_typeName;
/** @type {Array<glsUniformBlockCase.StructMember>} */ this.m_members = [];
};
/**
* glsUniformBlockCase.StructType - Constructor with type name
* @param {string} typeName
* @return {glsUniformBlockCase.StructType} The currently modified object.
*/
glsUniformBlockCase.StructType.prototype.Constructor = function(typeName) {
/** @type {string}*/ this.m_typeName = typeName;
return this;
};
/** getTypeName
* @return {string}
**/
glsUniformBlockCase.StructType.prototype.getTypeName = function() {
return this.m_typeName;
};
/*
* Instead of iterators, we'll add
* a getter for a specific element (getMember),
* and current members amount (getSize).
*/
/** getMember
* @param {number} memberNdx The index of the member to retrieve.
* @return {glsUniformBlockCase.StructMember}
**/
glsUniformBlockCase.StructType.prototype.getMember = function(memberNdx) {
if (memberNdx >= 0 && memberNdx < this.m_members.length)
return this.m_members[memberNdx];
else {
throw new Error("Invalid member index for glsUniformBlockCase.StructType's members");
}
};
/** getSize
* @return {number} The size of the m_members array.
**/
glsUniformBlockCase.StructType.prototype.getSize = function() {
return this.m_members.length;
};
/** addMember
* @param {string} member_name
* @param {glsUniformBlockCase.VarType} member_type
* @param {number=} member_flags
**/
glsUniformBlockCase.StructType.prototype.addMember = function(member_name, member_type, member_flags) {
var member = glsUniformBlockCase.newStructMember(member_name, member_type, member_flags);
this.m_members.push(member);
};
/**
* Creates a glsUniformBlockCase.StructType.
* @param {string} name
* @return {glsUniformBlockCase.StructType}
*/
glsUniformBlockCase.newStructType = function(name) {
return new glsUniformBlockCase.StructType().Constructor(name);
};
/** glsUniformBlockCase.Uniform
* @param {string} name
* @param {glsUniformBlockCase.VarType} type
* @param {number=} flags
* @constructor
**/
glsUniformBlockCase.Uniform = function(name, type, flags) {
/** @type {string} */ this.m_name = name;
/** @type {glsUniformBlockCase.VarType} */ this.m_type = type;
/** @type {number} */ this.m_flags = (typeof flags === 'undefined') ? 0 : flags;
};
/** getName
* @return {string}
*/
glsUniformBlockCase.Uniform.prototype.getName = function() {
return this.m_name;
};
/** getType
* @return {glsUniformBlockCase.VarType}
*/
glsUniformBlockCase.Uniform.prototype.getType = function() {
return this.m_type;
};
/** getFlags
* @return {number}
**/
glsUniformBlockCase.Uniform.prototype.getFlags = function() {
return this.m_flags;
};
/** glsUniformBlockCase.UniformBlock
* @param {string} blockName
* @constructor
**/
glsUniformBlockCase.UniformBlock = function(blockName) {
/** @type {string} */ this.m_blockName = blockName;
/** @type {string} */ this.m_instanceName;
/** @type {Array<glsUniformBlockCase.Uniform>} */ this.m_uniforms = [];
/** @type {number} */ this.m_arraySize = 0; //!< Array size or 0 if not interface block array.
/** @type {number} */ this.m_flags = 0;
};
/** getBlockName
* @return {string}
**/
glsUniformBlockCase.UniformBlock.prototype.getBlockName = function() {
return this.m_blockName;
};
/** getInstanceName
* @return {string}
**/
glsUniformBlockCase.UniformBlock.prototype.getInstanceName = function() {
return this.m_instanceName;
};
/** isArray
* @return {boolean}
**/
glsUniformBlockCase.UniformBlock.prototype.isArray = function() {
return this.m_arraySize > 0;
};
/** getArraySize
* @return {number}
**/
glsUniformBlockCase.UniformBlock.prototype.getArraySize = function() {
return this.m_arraySize;
};
/** getFlags
* @return {number}
**/
glsUniformBlockCase.UniformBlock.prototype.getFlags = function() {
return this.m_flags;
};
/** setInstanceName
* @param {string} name
**/
glsUniformBlockCase.UniformBlock.prototype.setInstanceName = function(name) {
this.m_instanceName = name;
};
/** setFlags
* @param {number} flags
**/
glsUniformBlockCase.UniformBlock.prototype.setFlags = function(flags) {
this.m_flags = flags;
};
/** setArraySize
* @param {number} arraySize
**/
glsUniformBlockCase.UniformBlock.prototype.setArraySize = function(arraySize) {
this.m_arraySize = arraySize;
};
/** addUniform
* @param {glsUniformBlockCase.Uniform} uniform
**/
glsUniformBlockCase.UniformBlock.prototype.addUniform = function(uniform) {
this.m_uniforms.push(uniform);
};
/*
* Using uniform getter (getUniform),
* and uniform array size getter (countUniforms)
* instead of iterators.
*/
/**
* getUniform
* @param {number} index
* @return {glsUniformBlockCase.Uniform}
*/
glsUniformBlockCase.UniformBlock.prototype.getUniform = function(index) {
if (index >= 0 && index < this.m_uniforms.length)
return this.m_uniforms[index];
else {
throw new Error("Invalid uniform index for glsUniformBlockCase.UniformBlock's uniforms");
}
};
/**
* countUniforms
* @return {number}
*/
glsUniformBlockCase.UniformBlock.prototype.countUniforms = function() {
return this.m_uniforms.length;
};
/**
* glsUniformBlockCase.ShaderInterface
* @constructor
*/
glsUniformBlockCase.ShaderInterface = function() {
/** @type {Array<glsUniformBlockCase.StructType>} */ this.m_structs = [];
/** @type {Array<glsUniformBlockCase.UniformBlock>} */ this.m_uniformBlocks = [];
};
/** allocStruct
* @param {string} name
* @return {glsUniformBlockCase.StructType}
**/
glsUniformBlockCase.ShaderInterface.prototype.allocStruct = function(name) {
//m_structs.reserve(m_structs.length + 1);
this.m_structs.push(glsUniformBlockCase.newStructType(name));
return this.m_structs[this.m_structs.length - 1];
};
/** findStruct
* @param {string} name
* @return {glsUniformBlockCase.StructType}
**/
glsUniformBlockCase.ShaderInterface.prototype.findStruct = function(name) {
for (var pos = 0; pos < this.m_structs.length; pos++) {
if (this.m_structs[pos].getTypeName() == name)
return this.m_structs[pos];
}
return null;
};
/** getNamedStructs
* @param {Array<glsUniformBlockCase.StructType>} structs
**/
glsUniformBlockCase.ShaderInterface.prototype.getNamedStructs = function(structs) {
for (var pos = 0; pos < this.m_structs.length; pos++) {
if (this.m_structs[pos].getTypeName() != undefined)
structs.push(this.m_structs[pos]);
}
};
/** allocBlock
* @param {string} name
* @return {glsUniformBlockCase.UniformBlock}
**/
glsUniformBlockCase.ShaderInterface.prototype.allocBlock = function(name) {
this.m_uniformBlocks.push(new glsUniformBlockCase.UniformBlock(name));
return this.m_uniformBlocks[this.m_uniformBlocks.length - 1];
};
/** getNumUniformBlocks
* @return {number}
**/
glsUniformBlockCase.ShaderInterface.prototype.getNumUniformBlocks = function() {
return this.m_uniformBlocks.length;
};
/** getUniformBlock
* @param {number} ndx
* @return {glsUniformBlockCase.UniformBlock}
**/
glsUniformBlockCase.ShaderInterface.prototype.getUniformBlock = function(ndx) {
return this.m_uniformBlocks[ndx];
};
/**
* @constructor
*/
glsUniformBlockCase.BlockLayoutEntry = function() {
return {
/** @type {number} */ size: 0,
/** @type {string} */ name: '',
/** @type {Array<number>} */ activeUniformIndices: []
};
};
/**
* @constructor
*/
glsUniformBlockCase.UniformLayoutEntry = function() {
return {
/** @type {string} */ name: '',
/** @type {gluShaderUtil.DataType} */ type: gluShaderUtil.DataType.INVALID,
/** @type {number} */ size: 0,
/** @type {number} */ blockNdx: -1,
/** @type {number} */ offset: -1,
/** @type {number} */ arrayStride: -1,
/** @type {number} */ matrixStride: -1,
/** @type {boolean} */ isRowMajor: false
};
};
/**
* @constructor
*/
glsUniformBlockCase.UniformLayout = function() {
/** @type {Array<glsUniformBlockCase.BlockLayoutEntry>}*/ this.blocks = [];
/** @type {Array<glsUniformBlockCase.UniformLayoutEntry>}*/ this.uniforms = [];
};
/** getUniformIndex, returns a uniform index number in the layout,
* given the uniform's name.
* @param {string} name
* @return {number} uniform's index
*/
glsUniformBlockCase.UniformLayout.prototype.getUniformIndex = function(name) {
for (var ndx = 0; ndx < this.uniforms.length; ndx++) {
if (this.uniforms[ndx].name == name)
return ndx;
}
return -1;
};
/** getBlockIndex, returns a block index number in the layout,
* given the block's name.
* @param {string} name the name of the block
* @return {number} block's index
*/
glsUniformBlockCase.UniformLayout.prototype.getBlockIndex = function(name) {
for (var ndx = 0; ndx < this.blocks.length; ndx++) {
if (this.blocks[ndx].name == name)
return ndx;
}
return -1;
};
/**
* @enum {number}
*/
glsUniformBlockCase.BufferMode = {
BUFFERMODE_SINGLE: 0, //!< Single buffer shared between uniform blocks.
BUFFERMODE_PER_BLOCK: 1 //!< Per-block buffers
};
glsUniformBlockCase.BufferMode.BUFFERMODE_LAST = Object.keys(glsUniformBlockCase.BufferMode).length;
/**
* glsUniformBlockCase.PrecisionFlagsFmt
* @param {number} flags
* @return {string}
*/
glsUniformBlockCase.PrecisionFlagsFmt = function(flags) {
// Precision.
DE_ASSERT(deMath.dePop32(flags & (glsUniformBlockCase.UniformFlags.PRECISION_LOW | glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM | glsUniformBlockCase.UniformFlags.PRECISION_HIGH)) <= 1);
var str = '';
str += (flags & glsUniformBlockCase.UniformFlags.PRECISION_LOW ? 'lowp' :
flags & glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM ? 'mediump' :
flags & glsUniformBlockCase.UniformFlags.PRECISION_HIGH ? 'highp' : '');
return str;
};
/**
* glsUniformBlockCase.LayoutFlagsFmt
* @param {number} flags_
* @return {string}
*/
glsUniformBlockCase.LayoutFlagsFmt = function(flags_) {
var str = '';
var bitDesc =
[{ bit: glsUniformBlockCase.UniformFlags.LAYOUT_SHARED, token: 'shared' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_PACKED, token: 'packed' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_STD140, token: 'std140' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR, token: 'row_major' }, { bit: glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR, token: 'column_major' }
];
/** @type {number} */ var remBits = flags_;
for (var descNdx = 0; descNdx < bitDesc.length; descNdx++) {
if (remBits & bitDesc[descNdx].bit) {
if (remBits != flags_)
str += ', ';
str += bitDesc[descNdx].token;
remBits &= (~bitDesc[descNdx].bit) & 0xFFFFFFFF; //0xFFFFFFFF truncate to 32 bit value
}
}
DE_ASSERT(remBits == 0);
return str;
};
/**
* @constructor
*/
glsUniformBlockCase.UniformBufferManager = function(renderCtx) {
this.m_renderCtx = renderCtx;
/** @type {Array<number>} */ this.m_buffers = [];
};
/**
* allocBuffer
* @return {WebGLBuffer}
*/
glsUniformBlockCase.UniformBufferManager.prototype.allocBuffer = function() {
/** @type {WebGLBuffer} */ var buf = this.m_renderCtx.createBuffer();
this.m_buffers.push(buf);
return buf;
};
/**
* @param {string} name
* @param {string} description
* @param {glsUniformBlockCase.BufferMode} bufferMode
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
glsUniformBlockCase.UniformBlockCase = function(name, description, bufferMode) {
tcuTestCase.DeqpTest.call(this, name, description);
/** @type {string} */ this.m_name = name;
/** @type {string} */ this.m_description = description;
/** @type {glsUniformBlockCase.BufferMode} */ this.m_bufferMode = bufferMode;
/** @type {glsUniformBlockCase.ShaderInterface} */ this.m_interface = new glsUniformBlockCase.ShaderInterface();
};
glsUniformBlockCase.UniformBlockCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
glsUniformBlockCase.UniformBlockCase.prototype.constructor = glsUniformBlockCase.UniformBlockCase;
/**
* glsUniformBlockCase.getDataTypeByteSize
* @param {gluShaderUtil.DataType} type
* @return {number}
*/
glsUniformBlockCase.getDataTypeByteSize = function(type) {
return gluShaderUtil.getDataTypeScalarSize(type) * deMath.INT32_SIZE;
};
/**
* glsUniformBlockCase.getDataTypeByteAlignment
* @param {gluShaderUtil.DataType} type
* @return {number}
*/
glsUniformBlockCase.getDataTypeByteAlignment = function(type) {
switch (type) {
case gluShaderUtil.DataType.FLOAT:
case gluShaderUtil.DataType.INT:
case gluShaderUtil.DataType.UINT:
case gluShaderUtil.DataType.BOOL: return 1 * deMath.INT32_SIZE;
case gluShaderUtil.DataType.FLOAT_VEC2:
case gluShaderUtil.DataType.INT_VEC2:
case gluShaderUtil.DataType.UINT_VEC2:
case gluShaderUtil.DataType.BOOL_VEC2: return 2 * deMath.INT32_SIZE;
case gluShaderUtil.DataType.FLOAT_VEC3:
case gluShaderUtil.DataType.INT_VEC3:
case gluShaderUtil.DataType.UINT_VEC3:
case gluShaderUtil.DataType.BOOL_VEC3: // Fall-through to vec4
case gluShaderUtil.DataType.FLOAT_VEC4:
case gluShaderUtil.DataType.INT_VEC4:
case gluShaderUtil.DataType.UINT_VEC4:
case gluShaderUtil.DataType.BOOL_VEC4: return 4 * deMath.INT32_SIZE;
default:
DE_ASSERT(false);
return 0;
}
};
/**
* glsUniformBlockCase.getDataTypeArrayStride
* @param {gluShaderUtil.DataType} type
* @return {number}
*/
glsUniformBlockCase.getDataTypeArrayStride = function(type) {
DE_ASSERT(!gluShaderUtil.isDataTypeMatrix(type));
/** @type {number} */ var baseStride = glsUniformBlockCase.getDataTypeByteSize(type);
/** @type {number} */ var vec4Alignment = deMath.INT32_SIZE * 4;
DE_ASSERT(baseStride <= vec4Alignment);
return Math.max(baseStride, vec4Alignment); // Really? See rule 4.
};
/**
* glsUniformBlockCase.deRoundUp32 Rounds up 'a' in case the
* relationship with 'b' has a decimal part.
* @param {number} a
* @param {number} b
* @return {number}
*/
glsUniformBlockCase.deRoundUp32 = function(a, b) {
var d = Math.trunc(a / b);
return d * b == a ? a : (d + 1) * b;
};
/**
* glsUniformBlockCase.computeStd140BaseAlignment
* @param {glsUniformBlockCase.VarType} type
* @return {number}
*/
glsUniformBlockCase.computeStd140BaseAlignment = function(type) {
/** @type {number} */ var vec4Alignment = deMath.INT32_SIZE * 4;
if (type.isBasicType()) {
/** @type {gluShaderUtil.DataType} */ var basicType = type.getBasicType();
if (gluShaderUtil.isDataTypeMatrix(basicType)) {
/** @type {boolean} */ var isRowMajor = !!(type.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR);
/** @type {number} */ var vecSize = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(basicType) :
gluShaderUtil.getDataTypeMatrixNumRows(basicType);
return glsUniformBlockCase.getDataTypeArrayStride(gluShaderUtil.getDataTypeFloatVec(vecSize));
} else
return glsUniformBlockCase.getDataTypeByteAlignment(basicType);
} else if (type.isArrayType()) {
/** @type {number} */ var elemAlignment = glsUniformBlockCase.computeStd140BaseAlignment(type.getElementType());
// Round up to alignment of vec4
return glsUniformBlockCase.deRoundUp32(elemAlignment, vec4Alignment);
} else {
DE_ASSERT(type.isStructType());
/** @type {number} */ var maxBaseAlignment = 0;
for (var memberNdx = 0; memberNdx < type.getStruct().getSize(); memberNdx++) {
/** @type {glsUniformBlockCase.StructMember} */ var memberIter = type.getStruct().getMember(memberNdx);
maxBaseAlignment = Math.max(maxBaseAlignment, glsUniformBlockCase.computeStd140BaseAlignment(memberIter.getType()));
}
return glsUniformBlockCase.deRoundUp32(maxBaseAlignment, vec4Alignment);
}
};
/**
* mergeLayoutflags
* @param {number} prevFlags
* @param {number} newFlags
* @return {number}
*/
glsUniformBlockCase.mergeLayoutFlags = function(prevFlags, newFlags) {
/** @type {number} */ var packingMask = glsUniformBlockCase.UniformFlags.LAYOUT_PACKED | glsUniformBlockCase.UniformFlags.LAYOUT_SHARED | glsUniformBlockCase.UniformFlags.LAYOUT_STD140;
/** @type {number} */ var matrixMask = glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR | glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR;
/** @type {number} */ var mergedFlags = 0;
mergedFlags |= ((newFlags & packingMask) ? newFlags : prevFlags) & packingMask;
mergedFlags |= ((newFlags & matrixMask) ? newFlags : prevFlags) & matrixMask;
return mergedFlags;
};
/**
* glsUniformBlockCase.computeStd140Layout_B
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {number} curOffset
* @param {number} curBlockNdx
* @param {string} curPrefix
* @param {glsUniformBlockCase.VarType} type
* @param {number} layoutFlags
* @return {number} //This is what would return in the curOffset output parameter in the original C++ project.
*/
glsUniformBlockCase.computeStd140Layout_B = function(layout, curOffset, curBlockNdx, curPrefix, type, layoutFlags) {
/** @type {number} */ var baseAlignment = glsUniformBlockCase.computeStd140BaseAlignment(type);
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entry;
/** @type {number} */ var stride;
/** @type {gluShaderUtil.DataType} */ var elemBasicType;
/** @type {boolean} */ var isRowMajor;
/** @type {number} */ var vecSize;
/** @type {number} */ var numVecs;
curOffset = deMath.deAlign32(curOffset, baseAlignment);
if (type.isBasicType()) {
/** @type {gluShaderUtil.DataType} */ var basicType = type.getBasicType();
entry = new glsUniformBlockCase.UniformLayoutEntry();
entry.name = curPrefix;
entry.type = basicType;
entry.size = 1;
entry.arrayStride = 0;
entry.matrixStride = 0;
entry.blockNdx = curBlockNdx;
if (gluShaderUtil.isDataTypeMatrix(basicType)) {
// Array of vectors as specified in rules 5 & 7.
isRowMajor = !!(layoutFlags & glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR);
vecSize = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(basicType) :
gluShaderUtil.getDataTypeMatrixNumRows(basicType);
numVecs = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(basicType) :
gluShaderUtil.getDataTypeMatrixNumColumns(basicType);
stride = glsUniformBlockCase.getDataTypeArrayStride(gluShaderUtil.getDataTypeFloatVec(vecSize));
entry.offset = curOffset;
entry.matrixStride = stride;
entry.isRowMajor = isRowMajor;
curOffset += numVecs * stride;
} else {
// Scalar or vector.
entry.offset = curOffset;
curOffset += glsUniformBlockCase.getDataTypeByteSize(basicType);
}
layout.uniforms.push(entry);
} else if (type.isArrayType()) {
/** @type {glsUniformBlockCase.VarType} */ var elemType = type.getElementType();
if (elemType.isBasicType() && !gluShaderUtil.isDataTypeMatrix(elemType.getBasicType())) {
// Array of scalars or vectors.
elemBasicType = elemType.getBasicType();
entry = new glsUniformBlockCase.UniformLayoutEntry();
stride = glsUniformBlockCase.getDataTypeArrayStride(elemBasicType);
entry.name = curPrefix + '[0]'; // Array uniforms are always postfixed with [0]
entry.type = elemBasicType;
entry.blockNdx = curBlockNdx;
entry.offset = curOffset;
entry.size = type.getArraySize();
entry.arrayStride = stride;
entry.matrixStride = 0;
curOffset += stride * type.getArraySize();
layout.uniforms.push(entry);
} else if (elemType.isBasicType() && gluShaderUtil.isDataTypeMatrix(elemType.getBasicType())) {
// Array of matrices.
elemBasicType = elemType.getBasicType();
isRowMajor = !!(layoutFlags & glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR);
vecSize = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(elemBasicType) :
gluShaderUtil.getDataTypeMatrixNumRows(elemBasicType);
numVecs = isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(elemBasicType) :
gluShaderUtil.getDataTypeMatrixNumColumns(elemBasicType);
stride = glsUniformBlockCase.getDataTypeArrayStride(gluShaderUtil.getDataTypeFloatVec(vecSize));
entry = new glsUniformBlockCase.UniformLayoutEntry();
entry.name = curPrefix + '[0]'; // Array uniforms are always postfixed with [0]
entry.type = elemBasicType;
entry.blockNdx = curBlockNdx;
entry.offset = curOffset;
entry.size = type.getArraySize();
entry.arrayStride = stride * numVecs;
entry.matrixStride = stride;
entry.isRowMajor = isRowMajor;
curOffset += numVecs * type.getArraySize() * stride;
layout.uniforms.push(entry);
} else {
DE_ASSERT(elemType.isStructType() || elemType.isArrayType());
for (var elemNdx = 0; elemNdx < type.getArraySize(); elemNdx++)
curOffset = glsUniformBlockCase.computeStd140Layout_B(layout, curOffset, curBlockNdx, curPrefix + '[' + elemNdx + ']', type.getElementType(), layoutFlags);
}
} else {
DE_ASSERT(type.isStructType());
for (var memberNdx = 0; memberNdx < type.getStruct().getSize(); memberNdx++) {
/** @type {glsUniformBlockCase.StructMember} */ var memberIter = type.getStruct().getMember(memberNdx);
curOffset = glsUniformBlockCase.computeStd140Layout_B(layout, curOffset, curBlockNdx, curPrefix + '.' + memberIter.getName(), memberIter.getType(), layoutFlags);
}
curOffset = deMath.deAlign32(curOffset, baseAlignment);
}
return curOffset;
};
/**
* glsUniformBlockCase.computeStd140Layout
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {glsUniformBlockCase.ShaderInterface} sinterface
*/
glsUniformBlockCase.computeStd140Layout = function(layout, sinterface) {
// \todo [2012-01-23 pyry] Uniforms in default block.
/** @type {number} */ var numUniformBlocks = sinterface.getNumUniformBlocks();
for (var blockNdx = 0; blockNdx < numUniformBlocks; blockNdx++) {
/** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
/** @type {boolean} */ var hasInstanceName = block.getInstanceName() !== undefined;
/** @type {string} */ var blockPrefix = hasInstanceName ? (block.getBlockName() + '.') : '';
/** @type {number} */ var curOffset = 0;
/** @type {number} */ var activeBlockNdx = layout.blocks.length;
/** @type {number} */ var firstUniformNdx = layout.uniforms.length;
for (var ubNdx = 0; ubNdx < block.countUniforms(); ubNdx++) {
/** @type {glsUniformBlockCase.Uniform} */ var uniform = block.getUniform(ubNdx);
curOffset = glsUniformBlockCase.computeStd140Layout_B(layout, curOffset, activeBlockNdx, blockPrefix + uniform.getName(), uniform.getType(), glsUniformBlockCase.mergeLayoutFlags(block.getFlags(), uniform.getFlags()));
}
/** @type {number} */ var uniformIndicesEnd = layout.uniforms.length;
/** @type {number} */ var blockSize = curOffset;
/** @type {number} */ var numInstances = block.isArray() ? block.getArraySize() : 1;
// Create block layout entries for each instance.
for (var instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) {
// Allocate entry for instance.
layout.blocks.push(new glsUniformBlockCase.BlockLayoutEntry());
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var blockEntry = layout.blocks[layout.blocks.length - 1];
blockEntry.name = block.getBlockName();
blockEntry.size = blockSize;
// Compute active uniform set for block.
for (var uniformNdx = firstUniformNdx; uniformNdx < uniformIndicesEnd; uniformNdx++)
blockEntry.activeUniformIndices.push(uniformNdx);
if (block.isArray())
blockEntry.name += '[' + instanceNdx + ']';
}
}
};
/**
* glsUniformBlockCase.generateValue - Value generator
* @param {glsUniformBlockCase.UniformLayoutEntry} entry
* @param {Uint8Array} basePtr
* @param {deRandom.Random} rnd
*/
glsUniformBlockCase.generateValue = function(entry, basePtr, rnd) {
/** @type {gluShaderUtil.DataType}*/ var scalarType = gluShaderUtil.getDataTypeScalarTypeAsDataType(entry.type); //Using a more appropriate function in this case.
/** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(entry.type);
/** @type {boolean} */ var isMatrix = gluShaderUtil.isDataTypeMatrix(entry.type);
/** @type {number} */ var numVecs = isMatrix ? (entry.isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(entry.type) : gluShaderUtil.getDataTypeMatrixNumColumns(entry.type)) : 1;
/** @type {number} */ var vecSize = scalarSize / numVecs;
/** @type {boolean} */ var isArray = entry.size > 1;
/** @type {number} */ var compSize = deMath.INT32_SIZE;
DE_ASSERT(scalarSize % numVecs == 0);
for (var elemNdx = 0; elemNdx < entry.size; elemNdx++) {
/** @type {Uint8Array} */ var elemPtr = basePtr.subarray(entry.offset + (isArray ? elemNdx * entry.arrayStride : 0));
for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
/** @type {Uint8Array} */ var vecPtr = elemPtr.subarray(isMatrix ? vecNdx * entry.matrixStride : 0);
for (var compNdx = 0; compNdx < vecSize; compNdx++) {
/** @type {Uint8Array} */ var compPtr = vecPtr.subarray(compSize * compNdx);
/** @type {number} */ var _random;
//Copy the random data byte per byte
var _size = glsUniformBlockCase.getDataTypeByteSize(scalarType);
var nbuffer = new ArrayBuffer(_size);
var nview = new DataView(nbuffer);
switch (scalarType) {
case gluShaderUtil.DataType.FLOAT:
_random = rnd.getInt(-9, 9);
nview.setFloat32(0, _random, littleEndian);
break;
case gluShaderUtil.DataType.INT:
_random = rnd.getInt(-9, 9);
nview.setInt32(0, _random, littleEndian);
break;
case gluShaderUtil.DataType.UINT:
_random = rnd.getInt(0, 9);
nview.setUint32(0, _random, littleEndian);
break;
// \note Random bit pattern is used for true values. Spec states that all non-zero values are
// interpreted as true but some implementations fail this.
case gluShaderUtil.DataType.BOOL:
_random = rnd.getBool() ? 1 : 0;
nview.setUint32(0, _random, littleEndian);
break;
default:
DE_ASSERT(false);
}
for (var i = 0; i < _size; i++) {
compPtr[i] = nview.getUint8(i);
}
}
}
}
};
/**
* glsUniformBlockCase.generateValues
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {glsUniformBlockCase.BlockPointers} blockPointers
* @param {number} seed
*/
glsUniformBlockCase.generateValues = function(layout, blockPointers, seed) {
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed);
/** @type {number} */ var numBlocks = layout.blocks.length;
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
/** @type {Uint8Array} */ var basePtr = blockPointers.find(blockNdx);
/** @type {number} */ var numEntries = layout.blocks[blockNdx].activeUniformIndices.length;
for (var entryNdx = 0; entryNdx < numEntries; entryNdx++) {
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entry = layout.uniforms[layout.blocks[blockNdx].activeUniformIndices[entryNdx]];
glsUniformBlockCase.generateValue(entry, basePtr, rnd);
}
}
};
// Shader generator.
/**
* glsUniformBlockCase.getCompareFuncForType
* @param {gluShaderUtil.DataType} type
* @return {string}
*/
glsUniformBlockCase.getCompareFuncForType = function(type) {
switch (type) {
case gluShaderUtil.DataType.FLOAT: return 'mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.FLOAT_VEC2: return 'mediump float compare_vec2 (highp vec2 a, highp vec2 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y); }\n';
case gluShaderUtil.DataType.FLOAT_VEC3: return 'mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); }\n';
case gluShaderUtil.DataType.FLOAT_VEC4: return 'mediump float compare_vec4 (highp vec4 a, highp vec4 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z)*compare_float(a.w, b.w); }\n';
case gluShaderUtil.DataType.FLOAT_MAT2: return 'mediump float compare_mat2 (highp mat2 a, highp mat2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT2X3: return 'mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT2X4: return 'mediump float compare_mat2x4 (highp mat2x4 a, highp mat2x4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT3X2: return 'mediump float compare_mat3x2 (highp mat3x2 a, highp mat3x2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT3: return 'mediump float compare_mat3 (highp mat3 a, highp mat3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT3X4: return 'mediump float compare_mat3x4 (highp mat3x4 a, highp mat3x4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT4X2: return 'mediump float compare_mat4x2 (highp mat4x2 a, highp mat4x2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2])*compare_vec2(a[3], b[3]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT4X3: return 'mediump float compare_mat4x3 (highp mat4x3 a, highp mat4x3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2])*compare_vec3(a[3], b[3]); }\n';
case gluShaderUtil.DataType.FLOAT_MAT4: return 'mediump float compare_mat4 (highp mat4 a, highp mat4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2])*compare_vec4(a[3], b[3]); }\n';
case gluShaderUtil.DataType.INT: return 'mediump float compare_int (highp int a, highp int b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.INT_VEC2: return 'mediump float compare_ivec2 (highp ivec2 a, highp ivec2 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.INT_VEC3: return 'mediump float compare_ivec3 (highp ivec3 a, highp ivec3 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.INT_VEC4: return 'mediump float compare_ivec4 (highp ivec4 a, highp ivec4 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.UINT: return 'mediump float compare_uint (highp uint a, highp uint b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.UINT_VEC2: return 'mediump float compare_uvec2 (highp uvec2 a, highp uvec2 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.UINT_VEC3: return 'mediump float compare_uvec3 (highp uvec3 a, highp uvec3 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.UINT_VEC4: return 'mediump float compare_uvec4 (highp uvec4 a, highp uvec4 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.BOOL: return 'mediump float compare_bool (bool a, bool b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.BOOL_VEC2: return 'mediump float compare_bvec2 (bvec2 a, bvec2 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.BOOL_VEC3: return 'mediump float compare_bvec3 (bvec3 a, bvec3 b) { return a == b ? 1.0 : 0.0; }\n';
case gluShaderUtil.DataType.BOOL_VEC4: return 'mediump float compare_bvec4 (bvec4 a, bvec4 b) { return a == b ? 1.0 : 0.0; }\n';
default:
throw new Error('Type "' + type + '" not supported.');
}
};
/**
* glsUniformBlockCase.getCompareDependencies
* @param {Array<gluShaderUtil.DataType>} compareFuncs Should contain unique elements
* @param {gluShaderUtil.DataType} basicType
*/
glsUniformBlockCase.getCompareDependencies = function(compareFuncs, basicType) {
switch (basicType) {
case gluShaderUtil.DataType.FLOAT_VEC2:
case gluShaderUtil.DataType.FLOAT_VEC3:
case gluShaderUtil.DataType.FLOAT_VEC4:
deUtil.dePushUniqueToArray(compareFuncs, gluShaderUtil.DataType.FLOAT);
deUtil.dePushUniqueToArray(compareFuncs, basicType);
break;
case gluShaderUtil.DataType.FLOAT_MAT2:
case gluShaderUtil.DataType.FLOAT_MAT2X3:
case gluShaderUtil.DataType.FLOAT_MAT2X4:
case gluShaderUtil.DataType.FLOAT_MAT3X2:
case gluShaderUtil.DataType.FLOAT_MAT3:
case gluShaderUtil.DataType.FLOAT_MAT3X4:
case gluShaderUtil.DataType.FLOAT_MAT4X2:
case gluShaderUtil.DataType.FLOAT_MAT4X3:
case gluShaderUtil.DataType.FLOAT_MAT4:
deUtil.dePushUniqueToArray(compareFuncs, gluShaderUtil.DataType.FLOAT);
deUtil.dePushUniqueToArray(compareFuncs, gluShaderUtil.getDataTypeFloatVec(gluShaderUtil.getDataTypeMatrixNumRows(basicType)));
deUtil.dePushUniqueToArray(compareFuncs, basicType);
break;
default:
deUtil.dePushUniqueToArray(compareFuncs, basicType);
break;
}
};
/**
* glsUniformBlockCase.collectUniqueBasicTypes_B
* @param {Array<gluShaderUtil.DataType>} basicTypes Should contain unique elements
* @param {glsUniformBlockCase.VarType} type
*/
glsUniformBlockCase.collectUniqueBasicTypes_B = function(basicTypes, type) {
if (type.isStructType()) {
/** @type {glsUniformBlockCase.StructType} */ var stype = type.getStruct();
for (var memberNdx = 0; memberNdx < stype.getSize(); memberNdx++)
glsUniformBlockCase.collectUniqueBasicTypes_B(basicTypes, stype.getMember(memberNdx).getType());
} else if (type.isArrayType())
glsUniformBlockCase.collectUniqueBasicTypes_B(basicTypes, type.getElementType());
else {
DE_ASSERT(type.isBasicType());
deUtil.dePushUniqueToArray(basicTypes, type.getBasicType());
}
};
/**
* glsUniformBlockCase.collectUniqueBasicTypes_A
* @param {Array<gluShaderUtil.DataType>} basicTypes Should contain unique elements
* @param {glsUniformBlockCase.UniformBlock} uniformBlock
*/
glsUniformBlockCase.collectUniqueBasicTypes_A = function(basicTypes, uniformBlock) {
for (var uniformNdx = 0; uniformNdx < uniformBlock.countUniforms(); uniformNdx++)
glsUniformBlockCase.collectUniqueBasicTypes_B(basicTypes, uniformBlock.getUniform(uniformNdx).getType());
};
/**
* glsUniformBlockCase.collectUniqueBasicTypes
* @param {Array<gluShaderUtil.DataType>} basicTypes Should contain unique elements
* @param {glsUniformBlockCase.ShaderInterface} sinterface
*/
glsUniformBlockCase.collectUniqueBasicTypes = function(basicTypes, sinterface) {
for (var ndx = 0; ndx < sinterface.getNumUniformBlocks(); ++ndx)
glsUniformBlockCase.collectUniqueBasicTypes_A(basicTypes, sinterface.getUniformBlock(ndx));
};
/**
* glsUniformBlockCase.collectUniqueBasicTypes
* @return {string} Was originally an output parameter. As it is a basic type, we have to return it instead.
* @param {glsUniformBlockCase.ShaderInterface} sinterface
*/
glsUniformBlockCase.generateCompareFuncs = function(sinterface) {
/** @type {string} */ var str = '';
/** @type {Array<gluShaderUtil.DataType>} */ var types = []; //Will contain unique elements.
/** @type {Array<gluShaderUtil.DataType>} */ var compareFuncs = []; //Will contain unique elements.
// Collect unique basic types
glsUniformBlockCase.collectUniqueBasicTypes(types, sinterface);
// Set of compare functions required
for (var typeNdx = 0; typeNdx < types.length; typeNdx++)
glsUniformBlockCase.getCompareDependencies(compareFuncs, types[typeNdx]);
for (var type in gluShaderUtil.DataType) {
if (compareFuncs.indexOf(gluShaderUtil.DataType[type]) > -1)
str += glsUniformBlockCase.getCompareFuncForType(gluShaderUtil.DataType[type]);
}
return str;
};
/**
* glsUniformBlockCase.Indent - Prints level_ number of tab chars
* @param {number} level_
* @return {string}
*/
glsUniformBlockCase.Indent = function(level_) {
var str = '';
for (var i = 0; i < level_; i++)
str += '\t';
return str;
};
/**
* glsUniformBlockCase.generateDeclaration_C
* @return {string} src
* @param {glsUniformBlockCase.StructType} structType
* @param {number} indentLevel
*/
glsUniformBlockCase.generateDeclaration_C = function(structType, indentLevel) {
/** @type {string} */ var src = '';
DE_ASSERT(structType.getTypeName() !== undefined);
src += glsUniformBlockCase.generateFullDeclaration(structType, indentLevel);
src += ';\n';
return src;
};
/**
* glsUniformBlockCase.generateFullDeclaration
* @return {string} src
* @param {glsUniformBlockCase.StructType} structType
* @param {number} indentLevel
*/
glsUniformBlockCase.generateFullDeclaration = function(structType, indentLevel) {
var src = 'struct';
if (structType.getTypeName())
src += ' ' + structType.getTypeName();
src += '\n' + glsUniformBlockCase.Indent(indentLevel) + ' {\n';
for (var memberNdx = 0; memberNdx < structType.getSize(); memberNdx++) {
src += glsUniformBlockCase.Indent(indentLevel + 1);
/** @type {glsUniformBlockCase.StructMember} */ var memberIter = structType.getMember(memberNdx);
src += glsUniformBlockCase.generateDeclaration_B(memberIter.getType(), memberIter.getName(), indentLevel + 1, memberIter.getFlags() & glsUniformBlockCase.UniformFlags.UNUSED_BOTH);
}
src += glsUniformBlockCase.Indent(indentLevel) + '}';
return src;
};
/**
* glsUniformBlockCase.generateLocalDeclaration
* @return {string} src
* @param {glsUniformBlockCase.StructType} structType
* @param {number} indentLevel
*/
glsUniformBlockCase.generateLocalDeclaration = function(structType, indentLevel) {
/** @type {string} */ var src = '';
if (structType.getTypeName() === undefined)
src += glsUniformBlockCase.generateFullDeclaration(structType, indentLevel);
else
src += structType.getTypeName();
return src;
};
/**
* glsUniformBlockCase.generateDeclaration_B
* @return {string} src
* @param {glsUniformBlockCase.VarType} type
* @param {string} name
* @param {number} indentLevel
* @param {number} unusedHints
*/
glsUniformBlockCase.generateDeclaration_B = function(type, name, indentLevel, unusedHints) {
/** @type {string} */ var src = '';
/** @type {number} */ var flags = type.getFlags();
if ((flags & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) != 0)
src += 'layout(' + glsUniformBlockCase.LayoutFlagsFmt(flags & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) + ') ';
if ((flags & glsUniformBlockCase.UniformFlags.PRECISION_MASK) != 0)
src += glsUniformBlockCase.PrecisionFlagsFmt(flags & glsUniformBlockCase.UniformFlags.PRECISION_MASK) + ' ';
if (type.isBasicType())
src += gluShaderUtil.getDataTypeName(type.getBasicType()) + ' ' + name;
else if (type.isArrayType()) {
/** @type {Array<number>} */ var arraySizes = [];
/** @type {glsUniformBlockCase.VarType} */ var curType = type;
while (curType.isArrayType()) {
arraySizes.push(curType.getArraySize());
curType = curType.getElementType();
}
if (curType.isBasicType()) {
if ((curType.getFlags() & glsUniformBlockCase.UniformFlags.PRECISION_MASK) != 0)
src += glsUniformBlockCase.PrecisionFlagsFmt(curType.getFlags() & glsUniformBlockCase.UniformFlags.PRECISION_MASK) + ' ';
src += gluShaderUtil.getDataTypeName(curType.getBasicType());
} else {
DE_ASSERT(curType.isStructType());
src += glsUniformBlockCase.generateLocalDeclaration(curType.getStruct(), indentLevel + 1);
}
src += ' ' + name;
for (var sizeNdx = 0; sizeNdx < arraySizes.length; sizeNdx++)
src += '[' + arraySizes[sizeNdx] + ']';
} else {
src += glsUniformBlockCase.generateLocalDeclaration(type.getStruct(), indentLevel + 1);
src += ' ' + name;
}
src += ';';
// Print out unused hints.
if (unusedHints != 0)
src += ' // unused in ' + (unusedHints == glsUniformBlockCase.UniformFlags.UNUSED_BOTH ? 'both shaders' :
unusedHints == glsUniformBlockCase.UniformFlags.UNUSED_VERTEX ? 'vertex shader' :
unusedHints == glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT ? 'fragment shader' : '???');
src += '\n';
return src;
};
/**
* glsUniformBlockCase.generateDeclaration_A
* @return {string} src
* @param {glsUniformBlockCase.Uniform} uniform
* @param {number} indentLevel
*/
glsUniformBlockCase.generateDeclaration_A = function(uniform, indentLevel) {
/** @type {string} */ var src = '';
if ((uniform.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) != 0)
src += 'layout(' + glsUniformBlockCase.LayoutFlagsFmt(uniform.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) + ') ';
src += glsUniformBlockCase.generateDeclaration_B(uniform.getType(), uniform.getName(), indentLevel, uniform.getFlags() & glsUniformBlockCase.UniformFlags.UNUSED_BOTH);
return src;
};
/**
* glsUniformBlockCase.generateDeclaration
* @return {string} src
* @param {glsUniformBlockCase.UniformBlock} block
*/
glsUniformBlockCase.generateDeclaration = function(block) {
/** @type {string} */ var src = '';
if ((block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) != 0)
src += 'layout(' + glsUniformBlockCase.LayoutFlagsFmt(block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_MASK) + ') ';
src += 'uniform ' + block.getBlockName();
src += '\n {\n';
for (var uniformNdx = 0; uniformNdx < block.countUniforms(); uniformNdx++) {
src += glsUniformBlockCase.Indent(1);
src += glsUniformBlockCase.generateDeclaration_A(block.getUniform(uniformNdx), 1 /* indent level */);
}
src += '}';
if (block.getInstanceName() !== undefined) {
src += ' ' + block.getInstanceName();
if (block.isArray())
src += '[' + block.getArraySize() + ']';
} else
DE_ASSERT(!block.isArray());
src += ';\n';
return src;
};
/**
* glsUniformBlockCase.newArrayBufferFromView - Creates a new buffer copying data from a given view
* @param {goog.NumberArray} view
* @return {ArrayBuffer} The newly created buffer
*/
glsUniformBlockCase.newArrayBufferFromView = function(view) {
var buffer = new ArrayBuffer(view.length * view.BYTES_PER_ELEMENT);
var copyview;
switch (view.BYTES_PER_ELEMENT) {
case 1:
copyview = new Uint8Array(buffer); break;
case 2:
copyview = new Uint16Array(buffer); break;
case 4:
copyview = new Uint32Array(buffer); break;
default:
assertMsgOptions(false, 'Unexpected value for BYTES_PER_ELEMENT in view', false, true);
}
for (var i = 0; i < view.length; i++)
copyview[i] = view[i];
return buffer;
};
/**
* glsUniformBlockCase.generateValueSrc
* @return {string} Used to be an output parameter in C++ project
* @param {glsUniformBlockCase.UniformLayoutEntry} entry
* @param {Uint8Array} basePtr
* @param {number} elementNdx
*/
glsUniformBlockCase.generateValueSrc = function(entry, basePtr, elementNdx) {
/** @type {string} */ var src = '';
/** @type {gluShaderUtil.DataType} */ var scalarType = gluShaderUtil.getDataTypeScalarTypeAsDataType(entry.type);
/** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(entry.type);
/** @type {boolean} */ var isArray = entry.size > 1;
/** @type {Uint8Array} */ var elemPtr = basePtr.subarray(entry.offset + (isArray ? elementNdx * entry.arrayStride : 0));
/** @type {number} */ var compSize = deMath.INT32_SIZE;
/** @type {Uint8Array} */ var compPtr;
if (scalarSize > 1)
src += gluShaderUtil.getDataTypeName(entry.type) + '(';
if (gluShaderUtil.isDataTypeMatrix(entry.type)) {
/** @type {number} */ var numRows = gluShaderUtil.getDataTypeMatrixNumRows(entry.type);
/** @type {number} */ var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(entry.type);
DE_ASSERT(scalarType == gluShaderUtil.DataType.FLOAT);
// Constructed in column-wise order.
for (var colNdx = 0; colNdx < numCols; colNdx++) {
for (var rowNdx = 0; rowNdx < numRows; rowNdx++) {
compPtr = elemPtr.subarray(entry.isRowMajor ? rowNdx * entry.matrixStride + colNdx * compSize :
colNdx * entry.matrixStride + rowNdx * compSize);
if (colNdx > 0 || rowNdx > 0)
src += ', ';
var newbuffer = new Uint8Array(compPtr.subarray(0, 4)).buffer;
var newview = new DataView(newbuffer);
src += parseFloat(newview.getFloat32(0, littleEndian)).toFixed(1);
}
}
} else {
for (var scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++) {
compPtr = elemPtr.subarray(scalarNdx * compSize);
if (scalarNdx > 0)
src += ', ';
var newbuffer = glsUniformBlockCase.newArrayBufferFromView(compPtr.subarray(0, 4));
var newview = new DataView(newbuffer);
switch (scalarType) {
case gluShaderUtil.DataType.FLOAT: src += parseFloat(newview.getFloat32(0, littleEndian) * 100 / 100).toFixed(1); break;
case gluShaderUtil.DataType.INT: src += newview.getInt32(0, littleEndian); break;
case gluShaderUtil.DataType.UINT: src += newview.getUint32(0, littleEndian) + 'u'; break;
case gluShaderUtil.DataType.BOOL: src += (newview.getUint32(0, littleEndian) != 0 ? 'true' : 'false'); break;
default:
DE_ASSERT(false);
}
}
}
if (scalarSize > 1)
src += ')';
return src;
};
/**
* glsUniformBlockCase.generateCompareSrc_A
* @return {string} Used to be an output parameter in C++ project
* @param {string} resultVar
* @param {glsUniformBlockCase.VarType} type
* @param {string} srcName
* @param {string} apiName
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {Uint8Array} basePtr
* @param {number} unusedMask
*/
glsUniformBlockCase.generateCompareSrc_A = function(resultVar, type, srcName, apiName, layout, basePtr, unusedMask) {
/** @type {string} */ var src = '';
/** @type {string} */ var op;
/** @type {glsUniformBlockCase.VarType|gluShaderUtil.DataType} */ var elementType;
if (type.isBasicType() || (type.isArrayType() && type.getElementType().isBasicType())) {
// Basic type or array of basic types.
/** @type {boolean} */ var isArray = type.isArrayType();
elementType = isArray ? type.getElementType().getBasicType() : type.getBasicType();
/** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(elementType);
/** @type {string} */ var fullApiName = apiName + (isArray ? '[0]' : ''); // Arrays are always postfixed with [0]
/** @type {number} */ var uniformNdx = layout.getUniformIndex(fullApiName);
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entry = layout.uniforms[uniformNdx];
if (isArray) {
for (var elemNdx = 0; elemNdx < type.getArraySize(); elemNdx++) {
src += '\tresult *= compare_' + typeName + '(' + srcName + '[' + elemNdx + '], ';
src += glsUniformBlockCase.generateValueSrc(entry, basePtr, elemNdx);
src += ');\n';
}
} else {
src += '\tresult *= compare_' + typeName + '(' + srcName + ', ';
src += glsUniformBlockCase.generateValueSrc(entry, basePtr, 0);
src += ');\n';
}
} else if (type.isArrayType()) {
elementType = type.getElementType();
for (var elementNdx = 0; elementNdx < type.getArraySize(); elementNdx++) {
op = '[' + elementNdx + ']';
src += glsUniformBlockCase.generateCompareSrc_A(resultVar, elementType, srcName + op, apiName + op, layout, basePtr, unusedMask);
}
} else {
DE_ASSERT(type.isStructType());
/** @type {glsUniformBlockCase.StructType} */ var stype = type.getStruct();
for (var memberNdx = 0; memberNdx < stype.getSize(); memberNdx++) {
/** @type {glsUniformBlockCase.StructMember} */ var memberIter = stype.getMember(memberNdx);
if (memberIter.getFlags() & unusedMask)
continue; // Skip member.
op = '.' + memberIter.getName();
src += glsUniformBlockCase.generateCompareSrc_A(resultVar, memberIter.getType(), srcName + op, apiName + op, layout, basePtr, unusedMask);
}
}
return src;
};
/**
* glsUniformBlockCase.generateCompareSrc
* @return {string} Used to be an output parameter in C++ project
* @param {string} resultVar
* @param {glsUniformBlockCase.ShaderInterface} sinterface
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {glsUniformBlockCase.BlockPointers} blockPointers
* @param {boolean} isVertex
*/
glsUniformBlockCase.generateCompareSrc = function(resultVar, sinterface, layout, blockPointers, isVertex) {
/** @type {string} */ var src = '';
/** @type {number} */ var unusedMask = isVertex ? glsUniformBlockCase.UniformFlags.UNUSED_VERTEX : glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT;
for (var blockNdx = 0; blockNdx < sinterface.getNumUniformBlocks(); blockNdx++) {
/** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
if ((block.getFlags() & (isVertex ? glsUniformBlockCase.UniformFlags.DECLARE_VERTEX : glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)) == 0)
continue; // Skip.
/** @type {boolean} */ var hasInstanceName = block.getInstanceName() !== undefined;
/** @type {boolean} */ var isArray = block.isArray();
/** @type {number} */ var numInstances = isArray ? block.getArraySize() : 1;
/** @type {string} */ var apiPrefix = hasInstanceName ? block.getBlockName() + '.' : '';
DE_ASSERT(!isArray || hasInstanceName);
for (var instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) {
/** @type {string} */ var instancePostfix = isArray ? '[' + instanceNdx + ']' : '';
/** @type {string} */ var blockInstanceName = block.getBlockName() + instancePostfix;
/** @type {string} */ var srcPrefix = hasInstanceName ? block.getInstanceName() + instancePostfix + '.' : '';
/** @type {number} */ var activeBlockNdx = layout.getBlockIndex(blockInstanceName);
/** @type {Uint8Array} */ var basePtr = blockPointers.find(activeBlockNdx);
for (var uniformNdx = 0; uniformNdx < block.countUniforms(); uniformNdx++) {
/** @type {glsUniformBlockCase.Uniform} */ var uniform = block.getUniform(uniformNdx);
if (uniform.getFlags() & unusedMask)
continue; // Don't read from that uniform.
src += glsUniformBlockCase.generateCompareSrc_A(resultVar, uniform.getType(), srcPrefix + uniform.getName(), apiPrefix + uniform.getName(), layout, basePtr, unusedMask);
}
}
}
return src;
};
/**
* glsUniformBlockCase.generateVertexShader
* @return {string} src
* @param {glsUniformBlockCase.ShaderInterface} sinterface
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {glsUniformBlockCase.BlockPointers} blockPointers
*/
glsUniformBlockCase.generateVertexShader = function(sinterface, layout, blockPointers) {
/** @type {string} */ var src = '';
DE_ASSERT(glsUniformBlockCase.isSupportedGLSLVersion(gluShaderUtil.getGLSLVersion(gl)));
src += gluShaderUtil.getGLSLVersionDeclaration(gluShaderUtil.getGLSLVersion(gl)) + '\n';
src += 'in highp vec4 a_position;\n';
src += 'out mediump float v_vtxResult;\n';
src += '\n';
/** @type {Array<glsUniformBlockCase.StructType>} */ var namedStructs = [];
sinterface.getNamedStructs(namedStructs);
for (var structNdx = 0; structNdx < namedStructs.length; structNdx++)
src += glsUniformBlockCase.generateDeclaration_C(namedStructs[structNdx], 0);
for (var blockNdx = 0; blockNdx < sinterface.getNumUniformBlocks(); blockNdx++) {
/** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
if (block.getFlags() & glsUniformBlockCase.UniformFlags.DECLARE_VERTEX)
src += glsUniformBlockCase.generateDeclaration(block);
}
// Comparison utilities.
src += '\n';
src += glsUniformBlockCase.generateCompareFuncs(sinterface);
src += '\n' +
'void main (void)\n' +
' {\n' +
' gl_Position = a_position;\n' +
' mediump float result = 1.0;\n';
// Value compare.
src += glsUniformBlockCase.generateCompareSrc('result', sinterface, layout, blockPointers, true);
src += ' v_vtxResult = result;\n' +
'}\n';
return src;
};
/**
* glsUniformBlockCase.generateFragmentShader
* @return {string} Used to be an output parameter
* @param {glsUniformBlockCase.ShaderInterface} sinterface
* @param {glsUniformBlockCase.UniformLayout} layout
* @param {glsUniformBlockCase.BlockPointers} blockPointers
*/
glsUniformBlockCase.generateFragmentShader = function(sinterface, layout, blockPointers) {
/** @type {string} */ var src = '';
DE_ASSERT(glsUniformBlockCase.isSupportedGLSLVersion(gluShaderUtil.getGLSLVersion(gl)));
src += gluShaderUtil.getGLSLVersionDeclaration(gluShaderUtil.getGLSLVersion(gl)) + '\n';
src += 'in mediump float v_vtxResult;\n';
src += 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n';
src += '\n';
/** @type {Array<glsUniformBlockCase.StructType>} */ var namedStructs = [];
sinterface.getNamedStructs(namedStructs);
for (var structNdx = 0; structNdx < namedStructs.length; structNdx++)
src += glsUniformBlockCase.generateDeclaration_C(namedStructs[structNdx], 0);
for (var blockNdx = 0; blockNdx < sinterface.getNumUniformBlocks(); blockNdx++) {
/** @type {glsUniformBlockCase.UniformBlock} */ var block = sinterface.getUniformBlock(blockNdx);
if (block.getFlags() & glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)
src += glsUniformBlockCase.generateDeclaration(block);
}
// Comparison utilities.
src += '\n';
src += glsUniformBlockCase.generateCompareFuncs(sinterface);
src += '\n' +
'void main (void)\n' +
' {\n' +
' mediump float result = 1.0;\n';
// Value compare.
src += glsUniformBlockCase.generateCompareSrc('result', sinterface, layout, blockPointers, false);
src += ' dEQP_FragColor = vec4(1.0, v_vtxResult, result, 1.0);\n' +
'}\n';
return src;
};
/**
* TODO: test glsUniformBlockCase.getGLUniformLayout Gets the uniform blocks and uniforms in the program.
* @param {WebGL2RenderingContext} gl
* @param {glsUniformBlockCase.UniformLayout} layout To store the layout described in program.
* @param {WebGLProgram} program id
*/
glsUniformBlockCase.getGLUniformLayout = function(gl, layout, program) {
/** @type {number} */ var numActiveUniforms = 0;
/** @type {number} */ var numActiveBlocks = 0;
numActiveUniforms = /** @type {number} */ (gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS)); // ACTIVE_UNIFORM* returns GLInt
numActiveBlocks = /** @type {number} */ (gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS));
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var entryBlock;
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var entryUniform;
/** @type {number} */ var size;
/** @type {number} */ var nameLen;
/** @type {string} */ var nameBuf;
/** @type {number} */ var numBlockUniforms;
// Block entries.
//No need to allocate these beforehand: layout.blocks.resize(numActiveBlocks);
for (var blockNdx = 0; blockNdx < numActiveBlocks; blockNdx++) {
entryBlock = new glsUniformBlockCase.BlockLayoutEntry();
size = /** @type {number} */ (gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_DATA_SIZE));
// nameLen not used so this line is removed.
// nameLen = gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_NAME_LENGTH); // TODO: UNIFORM_BLOCK_NAME_LENGTH is removed in WebGL2
numBlockUniforms = /** @type {number} */ (gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS));
nameBuf = gl.getActiveUniformBlockName(program, blockNdx);
entryBlock.name = nameBuf;
entryBlock.size = size;
//entry.activeUniformIndices.resize(numBlockUniforms);
if (numBlockUniforms > 0)
entryBlock.activeUniformIndices = gl.getActiveUniformBlockParameter(program, blockNdx, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
layout.blocks.push(entryBlock); //Pushing the block into the array here.
}
if (numActiveUniforms > 0) {
// glsUniformBlockCase.Uniform entries.
/** @type {Array<number>} */ var uniformIndices = [];
for (var i = 0; i < numActiveUniforms; i++)
uniformIndices.push(i);
/** @type {Array<number>} */ var types = [];
/** @type {Array<number>} */ var sizes = [];
/** @type {Array<number>} */ var nameLengths = [];
/** @type {Array<number>} */ var blockIndices = [];
/** @type {Array<number>} */ var offsets = [];
/** @type {Array<number>} */ var arrayStrides = [];
/** @type {Array<number>} */ var matrixStrides = [];
/** @type {Array<number>} */ var rowMajorFlags = [];
// Execute queries.
types = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_TYPE);
sizes = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_SIZE);
// Remove this: nameLengths = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_NAME_LENGTH);
blockIndices = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_BLOCK_INDEX);
offsets = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_OFFSET);
arrayStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_ARRAY_STRIDE);
matrixStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_MATRIX_STRIDE);
rowMajorFlags = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_IS_ROW_MAJOR);
// Translate to LayoutEntries
// No resize needed. Will push them: layout.uniforms.resize(numActiveUniforms);
for (var uniformNdx = 0; uniformNdx < numActiveUniforms; uniformNdx++) {
entryUniform = new glsUniformBlockCase.UniformLayoutEntry();
// Remove this: nameLen = 0;
size = 0;
/** @type {number} */ var type = gl.NONE;
var uniform = gl.getActiveUniform(program, uniformNdx);
nameBuf = uniform.name;
// Remove this: nameLen = nameBuf.length;
size = uniform.size;
type = uniform.type;
// Remove this: nameLen != nameLengths[uniformNdx] ||
if (size != sizes[uniformNdx] ||
type != types[uniformNdx])
testFailedOptions("Values returned by gl.getActiveUniform() don't match with values queried with gl.getActiveUniforms().", true);
entryUniform.name = nameBuf;
entryUniform.type = gluShaderUtil.getDataTypeFromGLType(types[uniformNdx]);
entryUniform.size = sizes[uniformNdx];
entryUniform.blockNdx = blockIndices[uniformNdx];
entryUniform.offset = offsets[uniformNdx];
entryUniform.arrayStride = arrayStrides[uniformNdx];
entryUniform.matrixStride = matrixStrides[uniformNdx];
entryUniform.isRowMajor = rowMajorFlags[uniformNdx] != false;
layout.uniforms.push(entryUniform); //Pushing this uniform in the end.
}
}
};
/**
* glsUniformBlockCase.copyUniformData_A - Copies a source uniform buffer segment to a destination uniform buffer segment.
* @param {glsUniformBlockCase.UniformLayoutEntry} dstEntry
* @param {Uint8Array} dstBlockPtr
* @param {glsUniformBlockCase.UniformLayoutEntry} srcEntry
* @param {Uint8Array} srcBlockPtr
*/
glsUniformBlockCase.copyUniformData_A = function(dstEntry, dstBlockPtr, srcEntry, srcBlockPtr) {
/** @type {Uint8Array} */ var dstBasePtr = dstBlockPtr.subarray(dstEntry.offset);
/** @type {Uint8Array} */ var srcBasePtr = srcBlockPtr.subarray(srcEntry.offset);
DE_ASSERT(dstEntry.size <= srcEntry.size);
DE_ASSERT(dstEntry.type == srcEntry.type);
/** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(dstEntry.type);
/** @type {boolean} */ var isMatrix = gluShaderUtil.isDataTypeMatrix(dstEntry.type);
/** @type {number} */ var compSize = deMath.INT32_SIZE;
for (var elementNdx = 0; elementNdx < dstEntry.size; elementNdx++) {
/** @type {Uint8Array} */ var dstElemPtr = dstBasePtr.subarray(elementNdx * dstEntry.arrayStride);
/** @type {Uint8Array} */ var srcElemPtr = srcBasePtr.subarray(elementNdx * srcEntry.arrayStride);
if (isMatrix) {
/** @type {number} */ var numRows = gluShaderUtil.getDataTypeMatrixNumRows(dstEntry.type);
/** @type {number} */ var numCols = gluShaderUtil.getDataTypeMatrixNumColumns(dstEntry.type);
for (var colNdx = 0; colNdx < numCols; colNdx++) {
for (var rowNdx = 0; rowNdx < numRows; rowNdx++) {
var srcoffset = dstEntry.isRowMajor ? rowNdx * dstEntry.matrixStride + colNdx * compSize :
colNdx * dstEntry.matrixStride + rowNdx * compSize;
/** @type {Uint8Array} */ var dstCompPtr = dstElemPtr.subarray(srcoffset, srcoffset + compSize);
var dstoffset = srcEntry.isRowMajor ? rowNdx * srcEntry.matrixStride + colNdx * compSize :
colNdx * srcEntry.matrixStride + rowNdx * compSize;
/** @type {Uint8Array} */ var srcCompPtr = srcElemPtr.subarray(dstoffset, dstoffset + compSize);
//Copy byte per byte
for (var i = 0; i < compSize; i++)
dstCompPtr[i] = srcCompPtr[i];
}
}
} else
//Copy byte per byte
for (var i = 0; i < scalarSize * compSize; i++)
dstElemPtr[i] = srcElemPtr[i];
}
};
/**
* glsUniformBlockCase.copyUniformData - Copies a source uniform buffer to a destination uniform buffer.
* @param {glsUniformBlockCase.UniformLayout} dstLayout
* @param {glsUniformBlockCase.BlockPointers} dstBlockPointers
* @param {glsUniformBlockCase.UniformLayout} srcLayout
* @param {glsUniformBlockCase.BlockPointers} srcBlockPointers
*/
glsUniformBlockCase.copyUniformData = function(dstLayout, dstBlockPointers, srcLayout, srcBlockPointers) {
// \note Src layout is used as reference in case of activeUniforms happens to be incorrect in dstLayout blocks.
/** @type {number} */ var numBlocks = srcLayout.blocks.length;
for (var srcBlockNdx = 0; srcBlockNdx < numBlocks; srcBlockNdx++) {
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var srcBlock = srcLayout.blocks[srcBlockNdx];
/** @type {Uint8Array} */ var srcBlockPtr = srcBlockPointers.find(srcBlockNdx);
/** @type {number} */ var dstBlockNdx = dstLayout.getBlockIndex(srcBlock.name);
/** @type {Uint8Array} */ var dstBlockPtr = dstBlockNdx >= 0 ? dstBlockPointers.find(dstBlockNdx) : null;
if (dstBlockNdx < 0)
continue;
for (var srcUniformNdx = 0; srcUniformNdx < srcBlock.activeUniformIndices.length; srcUniformNdx++) {
/** @type {number} */ var srcUniformNdxIter = srcBlock.activeUniformIndices[srcUniformNdx];
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var srcEntry = srcLayout.uniforms[srcUniformNdxIter];
/** @type {number} */ var dstUniformNdx = dstLayout.getUniformIndex(srcEntry.name);
if (dstUniformNdx < 0)
continue;
glsUniformBlockCase.copyUniformData_A(dstLayout.uniforms[dstUniformNdx], dstBlockPtr, srcEntry, srcBlockPtr);
}
}
};
/**
* TODO: Test with an actual WebGL 2.0 context
* iterate - The actual execution of the test.
* @return {tcuTestCase.IterateResult}
*/
glsUniformBlockCase.UniformBlockCase.prototype.iterate = function() {
/** @type {glsUniformBlockCase.UniformLayout} */ var refLayout = new glsUniformBlockCase.UniformLayout(); //!< std140 layout.
/** @type {glsUniformBlockCase.BlockPointers} */ var blockPointers = new glsUniformBlockCase.BlockPointers();
// Compute reference layout.
glsUniformBlockCase.computeStd140Layout(refLayout, this.m_interface);
// Assign storage for reference values.
/** @type {number} */ var totalSize = 0;
for (var blockNdx = 0; blockNdx < refLayout.blocks.length; blockNdx++) {
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var blockIter = refLayout.blocks[blockNdx];
totalSize += blockIter.size;
}
blockPointers.resize(totalSize);
// Pointers for each block.
var curOffset = 0;
for (var blockNdx = 0; blockNdx < refLayout.blocks.length; blockNdx++) {
var size = refLayout.blocks[blockNdx].size;
blockPointers.push(curOffset, size);
curOffset += size;
}
// Generate values.
glsUniformBlockCase.generateValues(refLayout, blockPointers, 1 /* seed */);
// Generate shaders and build program.
/** @type {string} */ var vtxSrc = glsUniformBlockCase.generateVertexShader(this.m_interface, refLayout, blockPointers);
/** @type {string} */ var fragSrc = glsUniformBlockCase.generateFragmentShader(this.m_interface, refLayout, blockPointers);
/** @type {gluShaderProgram.ShaderProgram}*/ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSrc, fragSrc));
bufferedLogToConsole(program.getProgramInfo().infoLog);
if (!program.isOk()) {
// Compile failed.
testFailedOptions('Compile failed', false);
return tcuTestCase.IterateResult.STOP;
}
// Query layout from GL.
/** @type {glsUniformBlockCase.UniformLayout} */ var glLayout = new glsUniformBlockCase.UniformLayout();
glsUniformBlockCase.getGLUniformLayout(gl, glLayout, program.getProgram());
// Print layout to log.
bufferedLogToConsole('Active glsUniformBlockCase.Uniform Blocks');
for (var blockNdx = 0; blockNdx < glLayout.blocks.length; blockNdx++)
bufferedLogToConsole(blockNdx + ': ' + glLayout.blocks[blockNdx]);
bufferedLogToConsole('Active Uniforms');
for (var uniformNdx = 0; uniformNdx < glLayout.uniforms.length; uniformNdx++)
bufferedLogToConsole(uniformNdx + ': ' + glLayout.uniforms[uniformNdx]);
// Check that we can even try rendering with given layout.
if (!this.checkLayoutIndices(glLayout) || !this.checkLayoutBounds(glLayout) || !this.compareTypes(refLayout, glLayout)) {
testFailedOptions('Invalid layout', false);
return tcuTestCase.IterateResult.STOP; // It is not safe to use the given layout.
}
// Verify all std140 blocks.
if (!this.compareStd140Blocks(refLayout, glLayout))
testFailedOptions('Invalid std140 layout', false);
// Verify all shared blocks - all uniforms should be active, and certain properties match.
if (!this.compareSharedBlocks(refLayout, glLayout))
testFailedOptions('Invalid shared layout', false);
// Check consistency with index queries
if (!this.checkIndexQueries(program.getProgram(), glLayout))
testFailedOptions('Inconsintent block index query results', false);
// Use program.
gl.useProgram(program.getProgram());
/** @type {number} */ var binding;
/** @type {WebGLBuffer} */ var buffer;
// Assign binding points to all active uniform blocks.
for (var blockNdx = 0; blockNdx < glLayout.blocks.length; blockNdx++) {
binding = blockNdx; // \todo [2012-01-25 pyry] Randomize order?
gl.uniformBlockBinding(program.getProgram(), blockNdx, binding);
}
/** @type {number} */ var numBlocks;
/** @type {glsUniformBlockCase.BlockPointers} */ var glBlockPointers;
// Allocate buffers, write data and bind to targets.
/** @type {glsUniformBlockCase.UniformBufferManager} */ var bufferManager = new glsUniformBlockCase.UniformBufferManager(gl);
if (this.m_bufferMode == glsUniformBlockCase.BufferMode.BUFFERMODE_PER_BLOCK) {
numBlocks = glLayout.blocks.length;
glBlockPointers = new glsUniformBlockCase.BlockPointers();
var totalsize = 0;
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++)
totalsize += glLayout.blocks[blockNdx].size;
glBlockPointers.resize(totalsize);
var offset = 0;
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
glBlockPointers.push(offset, glLayout.blocks[blockNdx].size);
offset += glLayout.blocks[blockNdx].size;
}
glsUniformBlockCase.copyUniformData(glLayout, glBlockPointers, refLayout, blockPointers);
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
buffer = bufferManager.allocBuffer();
binding = blockNdx;
gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
gl.bufferData(gl.UNIFORM_BUFFER, glBlockPointers.find(blockNdx) /*(glw::GLsizeiptr)glData[blockNdx].size(), &glData[blockNdx][0]*/, gl.STATIC_DRAW);
gl.bindBufferBase(gl.UNIFORM_BUFFER, binding, buffer);
}
} else {
DE_ASSERT(this.m_bufferMode == glsUniformBlockCase.BufferMode.BUFFERMODE_SINGLE);
totalSize = 0;
curOffset = 0;
numBlocks = glLayout.blocks.length;
/** @type {number} */ var bindingAlignment = 0;
glBlockPointers = new glsUniformBlockCase.BlockPointers();
bindingAlignment = /** @type {number} */ (gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT));
// Compute total size and offsets.
curOffset = 0;
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
if (bindingAlignment > 0)
curOffset = glsUniformBlockCase.deRoundUp32(curOffset, bindingAlignment);
glBlockPointers.push(curOffset, glLayout.blocks[blockNdx].size);
curOffset += glLayout.blocks[blockNdx].size;
}
totalSize = curOffset;
glBlockPointers.resize(totalSize);
// Copy to gl format.
glsUniformBlockCase.copyUniformData(glLayout, glBlockPointers, refLayout, blockPointers);
// Allocate buffer and upload data.
buffer = bufferManager.allocBuffer();
gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
if (glBlockPointers.data.byteLength > 0 /*!glData.empty()*/)
gl.bufferData(gl.UNIFORM_BUFFER, glBlockPointers.find(blockNdx) /*(glw::GLsizeiptr)glData.size(), &glData[0]*/, gl.STATIC_DRAW);
// Bind ranges to binding points.
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
binding = blockNdx;
gl.bindBufferRange(gl.UNIFORM_BUFFER, binding, buffer, glBlockPointers.offsets[blockNdx], glLayout.blocks[blockNdx].size);
}
}
/** @type {boolean} */ var renderOk = this.render(program);
if (!renderOk)
testFailedOptions('Image compare failed', false);
else
assertMsgOptions(renderOk, '', true, false);
return tcuTestCase.IterateResult.STOP;
};
/**
* compareStd140Blocks
* @param {glsUniformBlockCase.UniformLayout} refLayout
* @param {glsUniformBlockCase.UniformLayout} cmpLayout
**/
glsUniformBlockCase.UniformBlockCase.prototype.compareStd140Blocks = function(refLayout, cmpLayout) {
/**@type {boolean} */ var isOk = true;
/**@type {number} */ var numBlocks = this.m_interface.getNumUniformBlocks();
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
/**@type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.getUniformBlock(blockNdx);
/**@type {boolean} */ var isArray = block.isArray();
/**@type {string} */ var instanceName = block.getBlockName() + (isArray ? '[0]' : '');
/**@type {number} */ var refBlockNdx = refLayout.getBlockIndex(instanceName);
/**@type {number} */ var cmpBlockNdx = cmpLayout.getBlockIndex(instanceName);
/**@type {boolean} */ var isUsed = (block.getFlags() & (glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)) != 0;
if ((block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_STD140) == 0)
continue; // Not std140 layout.
DE_ASSERT(refBlockNdx >= 0);
if (cmpBlockNdx < 0) {
// Not found, should it?
if (isUsed) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform block '" + instanceName + "' not found");
isOk = false;
}
continue; // Skip block.
}
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var refBlockLayout = refLayout.blocks[refBlockNdx];
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx];
// \todo [2012-01-24 pyry] Verify that activeUniformIndices is correct.
// \todo [2012-01-24 pyry] Verify all instances.
if (refBlockLayout.activeUniformIndices.length != cmpBlockLayout.activeUniformIndices.length) {
bufferedLogToConsole("Error: Number of active uniforms differ in block '" + instanceName +
"' (expected " + refBlockLayout.activeUniformIndices.length +
', got ' + cmpBlockLayout.activeUniformIndices.length +
')');
isOk = false;
}
for (var ndx = 0; ndx < refBlockLayout.activeUniformIndices.length; ndx++) {
/** @type {number} */ var ndxIter = refBlockLayout.activeUniformIndices[ndx];
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var refEntry = refLayout.uniforms[ndxIter];
/** @type {number} */ var cmpEntryNdx = cmpLayout.getUniformIndex(refEntry.name);
if (cmpEntryNdx < 0) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + refEntry.name + "' not found");
isOk = false;
continue;
}
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var cmpEntry = cmpLayout.uniforms[cmpEntryNdx];
if (refEntry.type != cmpEntry.type ||
refEntry.size != cmpEntry.size ||
refEntry.offset != cmpEntry.offset ||
refEntry.arrayStride != cmpEntry.arrayStride ||
refEntry.matrixStride != cmpEntry.matrixStride ||
refEntry.isRowMajor != cmpEntry.isRowMajor) {
bufferedLogToConsole("Error: Layout mismatch in '" + refEntry.name + "':\n" +
' expected: type = ' + gluShaderUtil.getDataTypeName(refEntry.type) + ', size = ' + refEntry.size + ', row major = ' + (refEntry.isRowMajor ? 'true' : 'false') + '\n' +
' got: type = ' + gluShaderUtil.getDataTypeName(cmpEntry.type) + ', size = ' + cmpEntry.size + ', row major = ' + (cmpEntry.isRowMajor ? 'true' : 'false'));
isOk = false;
}
}
}
return isOk;
};
/**
* compareSharedBlocks
* @param {glsUniformBlockCase.UniformLayout} refLayout
* @param {glsUniformBlockCase.UniformLayout} cmpLayout
**/
glsUniformBlockCase.UniformBlockCase.prototype.compareSharedBlocks = function(refLayout, cmpLayout) {
/** @type {boolean} */ var isOk = true;
/** @type {number} */ var numBlocks = this.m_interface.getNumUniformBlocks();
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
/** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.getUniformBlock(blockNdx);
/** @type {boolean} */ var isArray = block.isArray();
/** @type {string} */ var instanceName = block.getBlockName() + (isArray ? '[0]' : '');
/** @type {number} */ var refBlockNdx = refLayout.getBlockIndex(instanceName);
/** @type {number} */ var cmpBlockNdx = cmpLayout.getBlockIndex(instanceName);
/** @type {boolean} */ var isUsed = (block.getFlags() & (glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT)) != 0;
if ((block.getFlags() & glsUniformBlockCase.UniformFlags.LAYOUT_SHARED) == 0)
continue; // Not shared layout.
DE_ASSERT(refBlockNdx >= 0);
if (cmpBlockNdx < 0) {
// Not found, should it?
if (isUsed) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform block '" + instanceName + "' not found");
isOk = false;
}
continue; // Skip block.
}
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var refBlockLayout = refLayout.blocks[refBlockNdx];
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx];
if (refBlockLayout.activeUniformIndices.length != cmpBlockLayout.activeUniformIndices.length) {
bufferedLogToConsole("Error: Number of active uniforms differ in block '" + instanceName +
"' (expected " + refBlockLayout.activeUniformIndices.length +
', got ' + cmpBlockLayout.activeUniformIndices.length +
')');
isOk = false;
}
for (var ndx = 0; ndx < refBlockLayout.activeUniformIndices.length; ndx++) {
/** @type {number} */ var ndxIter = refBlockLayout.activeUniformIndices[ndx];
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var refEntry = refLayout.uniforms[ndxIter];
/** @type {number} */ var cmpEntryNdx = cmpLayout.getUniformIndex(refEntry.name);
if (cmpEntryNdx < 0) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + refEntry.name + "' not found");
isOk = false;
continue;
}
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var cmpEntry = cmpLayout.uniforms[cmpEntryNdx];
if (refEntry.type != cmpEntry.type ||
refEntry.size != cmpEntry.size ||
refEntry.isRowMajor != cmpEntry.isRowMajor) {
bufferedLogToConsole("Error: Layout mismatch in '" + refEntry.name + "':\n" +
' expected: type = ' + gluShaderUtil.getDataTypeName(refEntry.type) + ', size = ' + refEntry.size + ', row major = ' + (refEntry.isRowMajor ? 'true' : 'false') + '\n' +
' got: type = ' + gluShaderUtil.getDataTypeName(cmpEntry.type) + ', size = ' + cmpEntry.size + ', row major = ' + (cmpEntry.isRowMajor ? 'true' : 'false'));
isOk = false;
}
}
}
return isOk;
};
/** compareTypes
* @param {glsUniformBlockCase.UniformLayout} refLayout
* @param {glsUniformBlockCase.UniformLayout} cmpLayout
* @return {boolean} true if uniform types are the same
**/
glsUniformBlockCase.UniformBlockCase.prototype.compareTypes = function(refLayout, cmpLayout) {
/** @type {boolean} */ var isOk = true;
/** @type {number} */ var numBlocks = this.m_interface.getNumUniformBlocks();
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
/** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.getUniformBlock(blockNdx);
/** @type {boolean} */ var isArray = block.isArray();
/** @type {number} */ var numInstances = isArray ? block.getArraySize() : 1;
for (var instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) {
/** @type {string} */ var instanceName;
instanceName += block.getBlockName();
if (isArray)
instanceName = instanceName + '[' + instanceNdx + ']';
/** @type {number} */ var cmpBlockNdx = cmpLayout.getBlockIndex(instanceName);
if (cmpBlockNdx < 0)
continue;
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx];
for (var ndx = 0; ndx < cmpBlockLayout.activeUniformIndices.length; ndx++) {
/** @type {number} */ var ndxIter = cmpBlockLayout.activeUniformIndices[ndx];
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var cmpEntry = cmpLayout.uniforms[ndxIter];
/** @type {number} */ var refEntryNdx = refLayout.getUniformIndex(cmpEntry.name);
if (refEntryNdx < 0) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + cmpEntry.name + "' not found in reference layout");
isOk = false;
continue;
}
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var refEntry = refLayout.uniforms[refEntryNdx];
// \todo [2012-11-26 pyry] Should we check other properties as well?
if (refEntry.type != cmpEntry.type) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform type mismatch in '" + refEntry.name + "':</br>" +
"' expected: '" + gluShaderUtil.getDataTypeName(refEntry.type) + "'</br>" +
"' got: '" + gluShaderUtil.getDataTypeName(cmpEntry.type) + "'");
isOk = false;
}
}
}
}
return isOk;
};
/** checkLayoutIndices
* @param {glsUniformBlockCase.UniformLayout} layout Layout whose indices are to be checked
* @return {boolean} true if all is ok
**/
glsUniformBlockCase.UniformBlockCase.prototype.checkLayoutIndices = function(layout) {
/** @type {number} */ var numUniforms = layout.uniforms.length;
/** @type {number} */ var numBlocks = layout.blocks.length;
/** @type {boolean} */ var isOk = true;
// Check uniform block indices.
for (var uniformNdx = 0; uniformNdx < numUniforms; uniformNdx++) {
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var uniform = layout.uniforms[uniformNdx];
if (uniform.blockNdx < 0 || !deMath.deInBounds32(uniform.blockNdx, 0, numBlocks)) {
bufferedLogToConsole("Error: Invalid block index in uniform '" + uniform.name + "'");
isOk = false;
}
}
// Check active uniforms.
for (var blockNdx = 0; blockNdx < numBlocks; blockNdx++) {
/** @type {glsUniformBlockCase.BlockLayoutEntry} */ var block = layout.blocks[blockNdx];
for (var uniformNdx = 0; uniformNdx < block.activeUniformIndices.length; uniformNdx++) {
/** @type {glsUniformBlockCase.UniformLayoutEntry} */ var activeUniformNdx = block.activeUniformIndices[uniformNdx];
if (!deMath.deInBounds32(activeUniformNdx, 0, numUniforms)) {
bufferedLogToConsole('Error: Invalid active uniform index ' + activeUniformNdx + " in block '" + block.name);
isOk = false;
}
}
}
return isOk;
};
/** checkLayoutBounds
* @param {glsUniformBlockCase.UniformLayout} layout The uniform layout to check
* @return {boolean} true if all is within bounds
**/
glsUniformBlockCase.UniformBlockCase.prototype.checkLayoutBounds = function(layout) {
/** @type {number} */ var numUniforms = layout.uniforms.length;
/** @type {boolean}*/ var isOk = true;
for (var uniformNdx = 0; uniformNdx < numUniforms; uniformNdx++) {
/** @type {glsUniformBlockCase.UniformLayoutEntry}*/ var uniform = layout.uniforms[uniformNdx];
if (uniform.blockNdx < 0)
continue;
/** @type {glsUniformBlockCase.BlockLayoutEntry}*/ var block = layout.blocks[uniform.blockNdx];
/** @type {boolean}*/ var isMatrix = gluShaderUtil.isDataTypeMatrix(uniform.type);
/** @type {number}*/ var numVecs = isMatrix ? (uniform.isRowMajor ? gluShaderUtil.getDataTypeMatrixNumRows(uniform.type) : gluShaderUtil.getDataTypeMatrixNumColumns(uniform.type)) : 1;
/** @type {number}*/ var numComps = isMatrix ? (uniform.isRowMajor ? gluShaderUtil.getDataTypeMatrixNumColumns(uniform.type) : gluShaderUtil.getDataTypeMatrixNumRows(uniform.type)) : gluShaderUtil.getDataTypeScalarSize(uniform.type);
/** @type {number}*/ var numElements = uniform.size;
/** @type {number}*/ var compSize = deMath.INT32_SIZE;
/** @type {number}*/ var vecSize = numComps * compSize;
/** @type {number}*/ var minOffset = 0;
/** @type {number}*/ var maxOffset = 0;
// For negative strides.
minOffset = Math.min(minOffset, (numVecs - 1) * uniform.matrixStride);
minOffset = Math.min(minOffset, (numElements - 1) * uniform.arrayStride);
minOffset = Math.min(minOffset, (numElements - 1) * uniform.arrayStride + (numVecs - 1) * uniform.matrixStride);
maxOffset = Math.max(maxOffset, vecSize);
maxOffset = Math.max(maxOffset, (numVecs - 1) * uniform.matrixStride + vecSize);
maxOffset = Math.max(maxOffset, (numElements - 1) * uniform.arrayStride + vecSize);
maxOffset = Math.max(maxOffset, (numElements - 1) * uniform.arrayStride + (numVecs - 1) * uniform.matrixStride + vecSize);
if (uniform.offset + minOffset < 0 || uniform.offset + maxOffset > block.size) {
bufferedLogToConsole("Error: glsUniformBlockCase.Uniform '" + uniform.name + "' out of block bounds");
isOk = false;
}
}
return isOk;
};
/** checkIndexQueries
* @param {WebGLProgram} program The shader program to be checked against
* @param {glsUniformBlockCase.UniformLayout} layout The layout to check
* @return {boolean} true if everything matches.
**/
glsUniformBlockCase.UniformBlockCase.prototype.checkIndexQueries = function(program, layout) {
/** @type {boolean}*/ var allOk = true;
// \note Spec mandates that uniform blocks are assigned consecutive locations from 0
// to ACTIVE_UNIFORM_BLOCKS. BlockLayoutEntries are stored in that order in glsUniformBlockCase.UniformLayout.
for (var blockNdx = 0; blockNdx < layout.blocks.length; blockNdx++) {
/** @const */ var block = layout.blocks[blockNdx];
/** @const */ var queriedNdx = gl.getUniformBlockIndex(program, block.name);
if (queriedNdx != blockNdx) {
bufferedLogToConsole('ERROR: glGetUniformBlockIndex(' + block.name + ') returned ' + queriedNdx + ', expected ' + blockNdx + '!');
allOk = false;
}
}
return allOk;
};
/** @const @type {number} */ glsUniformBlockCase.VIEWPORT_WIDTH = 128;
/** @const @type {number} */ glsUniformBlockCase.VIEWPORT_HEIGHT = 128;
/** Renders a white square, and then tests all pixels are
* effectively white in the color buffer.
* @param {gluShaderProgram.ShaderProgram} program The shader program to use.
* @return {boolean} false if there was at least one incorrect pixel
**/
glsUniformBlockCase.UniformBlockCase.prototype.render = function(program) {
// Compute viewport.
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name));
/** @const */ var viewportW = Math.min(gl.canvas.width, glsUniformBlockCase.VIEWPORT_WIDTH);
/** @const */ var viewportH = Math.min(gl.canvas.height, glsUniformBlockCase.VIEWPORT_HEIGHT);
/** @const */ var viewportX = rnd.getInt(0, gl.canvas.width);
/** @const */ var viewportY = rnd.getInt(0, gl.canvas.height);
gl.clearColor(0.125, 0.25, 0.5, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
//Draw
var position = [
-1.0, -1.0, 0.0, 1.0,
-1.0, 1.0, 0.0, 1.0,
1.0, -1.0, 0.0, 1.0,
1.0, 1.0, 0.0, 1.0
];
var indices = [0, 1, 2, 2, 1, 3];
gl.viewport(viewportX, viewportY, viewportW, viewportH);
// Access
var posLoc = gl.getAttribLocation(program.getProgram(), 'a_position');
var posArray = [new gluDrawUtil.VertexArrayBinding(gl.FLOAT, posLoc, 4, 4, position)];
gluDrawUtil.draw(gl, program.getProgram(), posArray, gluDrawUtil.triangles(indices));
// Verify that all pixels are white.
var pixels = new gluDrawUtil.Surface();
var numFailedPixels = 0;
var readPixelsX = (viewportX + viewportW) > gl.canvas.width
? (gl.canvas.width - viewportX) : viewportW;
var readPixelsY = (viewportY + viewportH) > gl.canvas.height
? (gl.canvas.height - viewportY) : viewportH;
var buffer = pixels.readSurface(gl, viewportX, viewportY, readPixelsX, readPixelsY);
var whitePixel = new gluDrawUtil.Pixel([255.0, 255.0, 255.0, 255.0]);
for (var y = 0; y < readPixelsY; y++) {
for (var x = 0; x < readPixelsX; x++) {
if (!pixels.getPixel(x, y).equals(whitePixel))
numFailedPixels += 1;
}
}
if (numFailedPixels > 0) {
bufferedLogToConsole('Image comparison failed, got ' + numFailedPixels + ' non-white pixels.');
}
return numFailedPixels == 0;
};
});