diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/framework/opengl/gluVarType.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/framework/opengl/gluVarType.js | 814 |
1 files changed, 814 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/framework/opengl/gluVarType.js b/dom/canvas/test/webgl-conf/checkout/deqp/framework/opengl/gluVarType.js new file mode 100644 index 0000000000..a05f1c1e5c --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/framework/opengl/gluVarType.js @@ -0,0 +1,814 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +'use strict'; +goog.provide('framework.opengl.gluVarType'); +goog.require('framework.opengl.gluShaderUtil'); + +goog.scope(function() { + + var gluVarType = framework.opengl.gluVarType; + var gluShaderUtil = framework.opengl.gluShaderUtil; + + /** + * gluVarType.VarType types enum + * @enum {number} + */ + gluVarType.Type = { + TYPE_BASIC: 0, + TYPE_ARRAY: 1, + TYPE_STRUCT: 2 + }; + + /** + * gluVarType.TypeArray struct + * @param {gluVarType.VarType} elementType + * @param {number} arraySize + * @constructor + */ + gluVarType.TypeArray = function(elementType, arraySize) { + /** @type {gluVarType.VarType} */ this.elementType = gluVarType.newClone(elementType); + /** @type {number} */ this.size = arraySize; + }; + + /** + * gluVarType.VarType class + * @constructor + */ + gluVarType.VarType = function() { + /** + * @type {gluShaderUtil.precision} + * @private + */ + this.m_flags; + + /** + * @type {number} + * @private + */ + this.m_type = -1; + + /** + * m_data used to be a 'Data' union in C++. Using a var is enough here. + * it will contain any necessary value. + * case TYPE_BASIC: number + * case TYPE_ARRAY: gluVarType.TypeArray + * case TYPE_STRUCT: gluVarType.StructType + * @private + * @type {(number|gluVarType.TypeArray|gluVarType.StructType)} + */ + this.m_data = null; + }; + + gluVarType.VarType.UNSIZED_ARRAY = -1; + + /** + * Creates a basic type gluVarType.VarType. Use this after the constructor call. + * @param {number} basicType + * @param {gluShaderUtil.precision} flags + * @return {gluVarType.VarType} The currently modified object + */ + gluVarType.VarType.prototype.VarTypeBasic = function(basicType, flags) { + this.m_type = gluVarType.Type.TYPE_BASIC; + this.m_flags = flags; + this.m_data = basicType; + + return this; + }; + + /** + * Creates a basic type gluVarType.VarType with type boolean and undefined precision. + * @param {number} basicType + * @return {gluVarType.VarType} The currently modified object + */ + gluVarType.VarType.prototype.VarTypeBoolean = function(basicType) { + this.m_type = gluVarType.Type.TYPE_BASIC; + this.m_data = basicType; + + return this; + }; + + /** + * Creates an array type gluVarType.VarType. Use this after the constructor call. + * @param {gluVarType.VarType} elementType + * @param {number} arraySize + * @return {gluVarType.VarType} The currently modified object + */ + gluVarType.VarType.prototype.VarTypeArray = function(elementType, arraySize) { + this.m_type = gluVarType.Type.TYPE_ARRAY; + if (!(arraySize >= 0 || arraySize == gluVarType.VarType.UNSIZED_ARRAY)) + throw new Error('Illegal array size: ' + arraySize); + this.m_data = new gluVarType.TypeArray(elementType, arraySize); + + return this; + }; + + /** + * Creates a struct type gluVarType.VarType. Use this after the constructor call. + * @param {gluVarType.StructType} structPtr + * @return {gluVarType.VarType} The currently modified object + */ + gluVarType.VarType.prototype.VarTypeStruct = function(structPtr) { + this.m_type = gluVarType.Type.TYPE_STRUCT; + this.m_data = structPtr; + + return this; + }; + + /** + * Creates a gluVarType.VarType, the same type as the passed in object. + * Use this after the constructor call. + * @param {gluVarType.VarType} object + * @return {gluVarType.VarType} The currently modified object + */ + gluVarType.VarType.prototype.VarTypeClone = function(object) { + + this.m_type = object.m_type; + + switch (this.m_type) { + case gluVarType.Type.TYPE_BASIC: + this.m_flags = object.m_flags; + this.m_data = object.m_data; + break; + case gluVarType.Type.TYPE_BASIC: + this.m_data = new gluVarType.TypeArray(object.m_data.elementType, object.m_data.size); + break; + case gluVarType.Type.TYPE_STRUCT: + this.m_data = object.m_data; + break; + default: + throw new Error('unknown type: ' + this.m_type); + } + + return this; + }; + + /** isBasicType + * @return {boolean} true if the gluVarType.VarType represents a basic type. + */ + gluVarType.VarType.prototype.isBasicType = function() { + return this.m_type == gluVarType.Type.TYPE_BASIC; + }; + + /** isArrayType + * @return {boolean} true if the gluVarType.VarType represents an array. + */ + gluVarType.VarType.prototype.isArrayType = function() { + return this.m_type == gluVarType.Type.TYPE_ARRAY; + }; + + /** isStructType + * @return {boolean} true if the gluVarType.VarType represents a struct. + */ + gluVarType.VarType.prototype.isStructType = function() { + return this.m_type == gluVarType.Type.TYPE_STRUCT; + }; + + /** getFlags + * @return {number} returns the flags of the gluVarType.VarType. + */ + gluVarType.VarType.prototype.getFlags = function() { + return this.m_flags; + }; + + /** getBasicType + * @return {gluShaderUtil.DataType<number>} returns the basic data type of the gluVarType.VarType. + */ + gluVarType.VarType.prototype.getBasicType = function() { + if (!this.isBasicType()) + throw new Error('VarType is not a basic type.'); + return /** @type {gluShaderUtil.DataType<number>} */ (this.m_data); + }; + + /** getPrecision + * @return {gluShaderUtil.precision} returns the precision flag. + */ + gluVarType.VarType.prototype.getPrecision = function() { + if (!this.isBasicType()) + throw new Error('VarType is not a basic type.'); + return this.m_flags; + }; + + /** getElementType + * @return {gluVarType.VarType} returns the gluVarType.VarType of the element in case of an Array. + */ + gluVarType.VarType.prototype.getElementType = function() { + if (!this.isArrayType()) + throw new Error('VarType is not an array type.'); + 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. + */ + gluVarType.VarType.prototype.getArraySize = function() { + if (!this.isArrayType()) + throw new Error('VarType is not an array type.'); + return this.m_data.size; + }; + + /** getStruct + * @return {gluVarType.StructType} returns the structure when it is a gluVarType.StructType. + */ + gluVarType.VarType.prototype.getStruct = function() { + if (!this.isStructType()) + throw new Error('VarType is not a struct type.'); + return /** @type {gluVarType.StructType} */ (this.m_data); + }; + + /** + * getScalarSize + * @return {number} size of the scalar + */ + gluVarType.VarType.prototype.getScalarSize = function() { + switch (this.m_type) { + case gluVarType.Type.TYPE_BASIC: { + return gluShaderUtil.getDataTypeScalarSize(/** @type {gluShaderUtil.DataType} */(this.getBasicType())); + } + + // TODO: check implementation below: return m_data.array.elementType->getScalarSize()*m_data.array.size; + case gluVarType.Type.TYPE_ARRAY: { + var m_data = /** @type {gluVarType.TypeArray} */(this.m_data); + return m_data.elementType.getScalarSize() * m_data.size; + } + + case gluVarType.Type.TYPE_STRUCT: { + var size = 0; + + var struct = /** @type {gluVarType.StructType} */ (this.m_data); + + // TODO: check loop conditions below + // for (gluVarType.StructType::ConstIterator iter = m_data.structPtr->begin(); iter != m_data.structPtr->end(); iter++) + for (var iter = 0; struct.m_members[iter] < struct.getSize(); iter++) + size += struct.getMember(iter).m_type.getScalarSize(); + return size; + } + + default: + // throw new Error('Unexpected type.'); + return 0; + } + }; + + /** + * is + * @return {boolean} returns true if the current object is equivalent to other. + */ + gluVarType.VarType.prototype.is = function(other) { + if (this.m_type != other.m_type) + return false; + + switch (this.m_type) { + case gluVarType.Type.TYPE_BASIC: + return this.m_data == other.m_data && + this.m_flags == other.m_flags; + + case gluVarType.Type.TYPE_ARRAY: + return this.m_data.elementType == other.m_data.elementType && + this.m_data.size == other.m_data.size; + + case gluVarType.Type.TYPE_STRUCT: + return this.m_data === other.m_data; + + default: + // throw new Error('Unexpected type.'); + return false; + } + }; + + /** + * isnt + * @return {boolean} returns true if the current object is not equivalent to other. + */ + gluVarType.VarType.prototype.isnt = function(other) { + return !(this.is(other)); + }; + + /** + * Creates a basic type gluVarType.VarType. + * @param {gluShaderUtil.DataType} basicType + * @param {framework.opengl.gluShaderUtil.precision=} flags + * @return {gluVarType.VarType} + */ + gluVarType.newTypeBasic = function(basicType, flags) { + if (!gluShaderUtil.isDataTypeBoolOrBVec(basicType)) + return new gluVarType.VarType().VarTypeBasic(basicType, /** @type {framework.opengl.gluShaderUtil.precision}*/ (flags)); + else + return new gluVarType.VarType().VarTypeBoolean(basicType); + }; + + /** + * Creates an array type gluVarType.VarType. + * @param {gluVarType.VarType} elementType + * @param {number} arraySize + * @return {gluVarType.VarType} + */ + gluVarType.newTypeArray = function(elementType, arraySize) { + return new gluVarType.VarType().VarTypeArray(elementType, arraySize); + }; + + /** + * Creates a struct type gluVarType.VarType. + * @param {gluVarType.StructType} structPtr + * @return {gluVarType.VarType} + */ + gluVarType.newTypeStruct = function(structPtr) { + return new gluVarType.VarType().VarTypeStruct(structPtr); + }; + + /** + * Creates a struct type gluVarType.VarType. + * @param {gluVarType.VarType} object + * @return {gluVarType.VarType} + */ + gluVarType.newClone = function(object) { + return new gluVarType.VarType().VarTypeClone(object); + }; + + /** + * gluVarType.StructMember class + * @constructor + */ + gluVarType.StructMember = function() { + /** @type {string} */ this.m_name; + /** @type {gluVarType.VarType} */ this.m_type; + /** @type {number} */ // this.m_flags = 0; // only in glsUniformBlockCase + }; + + /** + * Creates a gluVarType.StructMember. Use this after the constructor call. + * @param {string} name + * @param {gluVarType.VarType} type + * @return {gluVarType.StructMember} The currently modified object + */ + gluVarType.StructMember.prototype.Constructor = function(name, type) { + this.m_type = type; + this.m_name = name; + + return this; + }; + + /** getName + * @return {string} name of the gluVarType.StructMember object. + */ + gluVarType.StructMember.prototype.getName = function() { + return this.m_name; + }; + + /** getType + * @return {gluVarType.VarType} type of the gluVarType.StructMember object. + */ + gluVarType.StructMember.prototype.getType = function() { + return this.m_type; + }; + + /** + * Creates a gluVarType.StructMember. + * @param {string} name + * @param {gluVarType.VarType} type + * @return {gluVarType.StructMember} + */ + gluVarType.newStructMember = function(name, type) { + return new gluVarType.StructMember().Constructor(name, type); + }; + + /** + * gluVarType.StructType class + * @constructor + */ + gluVarType.StructType = function() { + /** @type {string} */ this.m_typeName = ''; + /** @type {Array<gluVarType.StructMember>} */ this.m_members = []; + }; + + /** + * Creates a gluVarType.StructType. Use this after the constructor call. + * @param {string} name + * @return {gluVarType.StructType} The currently modified object + */ + gluVarType.StructType.prototype.Constructor = function(name) { + /** @type {string}*/ this.m_typeName = this.setTypeName(name); + return this; + }; + + /** hasTypeName + * Checks if the gluVarType.StructType m_typeName is defined + * @return {boolean} + */ + gluVarType.StructType.prototype.hasTypeName = function() { + return (this.m_typeName !== 'undefined'); + }; + + /** setTypeName + * @param {string} name + * @return {string} returns gluVarType.StructType.m_typeName + */ + gluVarType.StructType.prototype.setTypeName = function(name) { + return this.m_typeName = name; + }; + + /** getTypeName + * @return {string} + */ + gluVarType.StructType.prototype.getTypeName = function() { + return this.m_typeName; + }; + + /** getNumMembers + * @return {number} + */ + gluVarType.StructType.prototype.getNumMembers = function() { + return this.m_members.length; + }; + + /** getMember + * @param {number} memberNdx The index of the member to retrieve. + * @return {gluVarType.StructMember} + */ + gluVarType.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 StructTypes members'); + } + }; + + /** getSize + * @return {number} The size of the m_members array. + */ + gluVarType.StructType.prototype.getSize = function() { + return this.m_members.length; + }; + + /** addMember + * @param {string} name + * @param {gluVarType.VarType} type + */ + gluVarType.StructType.prototype.addMember = function(name, type) { + var member = gluVarType.newStructMember(name, type); + this.m_members.push(member); + }; + + /** + * Creates a gluVarType.StructType. + * @param {string} name + * @return {gluVarType.StructType} + */ + gluVarType.newStructType = function(name) { + return new gluVarType.StructType().Constructor(name); + }; + + /** + * @param {number} level + * @return {string} + */ + gluVarType.indent = function(level) { + /** @type {string} */ var str = ''; + for (var i = 0; i < level; i++) + str += '\t'; + return str; + }; + + /** + * @param {gluVarType.VarType} varType + * @param {string} name + * @param {number=} level + * @return {string} + */ + gluVarType.declareVariable = function(varType, name, level) { + /** @type {string} */ var str = ''; + /** @type {gluVarType.VarType} */ var type = varType; + /** @type {gluVarType.VarType} */ var curType = type; + /** @type {Array<number>} */ var arraySizes = []; + + // Handle arrays. + while (curType.isArrayType()) { + arraySizes.push(curType.getArraySize()); + curType = curType.getElementType(); + } + + if (curType.isBasicType()) { + if (curType.getPrecision() !== undefined) + str += gluShaderUtil.getPrecisionName(curType.getPrecision()) + ' '; + str += gluShaderUtil.getDataTypeName(/** @type {gluShaderUtil.DataType} */(curType.getBasicType())); + } else if (curType.isStructType()) { + /** @type {gluVarType.StructType} */ var structPtr = curType.getStruct(); + + if (structPtr.hasTypeName()) + str += structPtr.getTypeName(); + else + str += gluVarType.declareStructType(structPtr, level); // Generate inline declaration. + } else + throw new Error('Unexpected Array typed VarType.'); + + str += ' ' + name; + + // Print array sizes. + for (var size = 0; size < arraySizes.length; size++) { //std::vector<int>::const_iterator sizeIter = arraySizes.begin(); sizeIter != arraySizes.end(); sizeIter++) { + /** @type {number} */ var arrSize = arraySizes[size]; + if (arrSize == gluVarType.VarType.UNSIZED_ARRAY) + str += '[]'; + else + str += '[' + arrSize + ']'; + } + + return str; + }; + + /** + * @param {gluVarType.StructType} structType + * @param {number=} level + * @return {string} + */ + gluVarType.declareStructType = function(structType, level) { + /** @type {string} */ var str = 'struct'; + level = level || 0; + + // gluVarType.Type name is optional. + if (structType.hasTypeName()) + str += ' ' + structType.getTypeName(); + + str += '\n' + gluVarType.indent(level) + ' {\n'; + + for (var memberNdx = 0; memberNdx < structType.getSize(); memberNdx++) { //gluVarType.StructType::ConstIterator memberIter = decl.structPtr->begin(); memberIter != decl.structPtr->end(); memberIter++) { + /** @type {gluVarType.StructMember} */ var memberIter = structType.getMember(memberNdx); + str += gluVarType.indent(level + 1); + str += gluVarType.declareVariable(memberIter.getType(), memberIter.getName(), level + 1) + ';\n'; + } + + str += gluVarType.indent(level) + '}'; + + return str; + }; + + /** + * @param {*} T + * @param {number=} size + * @param {gluShaderUtil.precision=} precision + * @return {gluVarType.VarType} + */ + gluVarType.getVarTypeOf = function(T, size, precision) { + size = size || 1; + precision = precision || gluShaderUtil.precision.PRECISION_LOWP; + switch (size) { + case 4: return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, precision); + case 3: return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC3, precision); + case 2: return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC2, precision); + } + switch (T) { + case 'float' : return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT, precision); + case 'vec4': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC4, precision); + case 'vec3': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC3, precision); + case 'vec2': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_VEC2, precision); + case 'mat2': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2, precision); + case 'mat2x3': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2X3, precision); + case 'mat2x4': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT2X4, precision); + case 'mat3x2': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3X2, precision); + case 'mat3': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3, precision); + case 'mat3x4': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT3X4, precision); + case 'mat4x2': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT4X2, precision); + case 'mat4x3': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT4X3, precision); + case 'mat4': return gluVarType.newTypeBasic(gluShaderUtil.DataType.FLOAT_MAT4, precision); + } + throw new Error('Invalid input type ' + T + ' or size ' + size); + }; + + /** + * @enum + */ + gluVarType.Storage = { + STORAGE_IN: 0, + STORAGE_OUT: 1, + STORAGE_CONST: 2, + STORAGE_UNIFORM: 3, + STORAGE_BUFFER: 4 + }; + + /** + * @param {gluVarType.Storage} storage + * @return {string} + */ + gluVarType.getStorageName = function(storage) { + switch (storage) { + case gluVarType.Storage.STORAGE_IN: return 'in'; + case gluVarType.Storage.STORAGE_OUT: return 'out'; + case gluVarType.Storage.STORAGE_CONST: return 'const'; + case gluVarType.Storage.STORAGE_UNIFORM: return 'uniform'; + case gluVarType.Storage.STORAGE_BUFFER: return 'buffer'; + default: + throw new Error('Unknown storage: ' + storage); + } + }; + + /** + * @enum + */ + gluVarType.Interpolation = { + INTERPOLATION_SMOOTH: 0, + INTERPOLATION_FLAT: 1, + INTERPOLATION_CENTROID: 2 + }; + + /** + * @param {gluVarType.Interpolation} interpolation + * @return {string} + */ + gluVarType.getInterpolationName = function(interpolation) { + switch (interpolation) { + case gluVarType.Interpolation.INTERPOLATION_SMOOTH: return 'smooth'; + case gluVarType.Interpolation.INTERPOLATION_FLAT: return 'flat'; + case gluVarType.Interpolation.INTERPOLATION_CENTROID: return 'centrod'; + default: + throw new Error('Unknown interpolation: ' + interpolation); + } + }; + + /** + * @enum + */ + gluVarType.FormatLayout = { + FORMATLAYOUT_RGBA32F: 0, + FORMATLAYOUT_RGBA16F: 1, + FORMATLAYOUT_R32F: 2, + FORMATLAYOUT_RGBA8: 3, + FORMATLAYOUT_RGBA8_SNORM: 4, + + FORMATLAYOUT_RGBA32I: 5, + FORMATLAYOUT_RGBA16I: 6, + FORMATLAYOUT_RGBA8I: 7, + FORMATLAYOUT_R32I: 8, + + FORMATLAYOUT_RGBA32UI: 9, + FORMATLAYOUT_RGBA16UI: 10, + FORMATLAYOUT_RGBA8UI: 11, + FORMATLAYOUT_R32UI: 12 + }; + + /** + * @param {gluVarType.FormatLayout} layout + * @return {string} + */ + gluVarType.getFormatLayoutName = function(layout) { + switch (layout) { + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA32F: return 'rgba32f'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA16F: return 'rgba16f'; + case gluVarType.FormatLayout.FORMATLAYOUT_R32F: return 'r32f'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA8: return 'rgba8'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA8_SNORM: return 'rgba8_snorm'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA32I: return 'rgba32i'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA16I: return 'rgba16i'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA8I: return 'rgba8i'; + case gluVarType.FormatLayout.FORMATLAYOUT_R32I: return 'r32i'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA32UI: return 'rgba32ui'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA16UI: return 'rgba16ui'; + case gluVarType.FormatLayout.FORMATLAYOUT_RGBA8UI: return 'rgba8ui'; + case gluVarType.FormatLayout.FORMATLAYOUT_R32UI: return 'r32ui'; + default: + throw new Error('Unknown layout: ' + layout); + } + }; + + /** + * @enum + */ + gluVarType.MatrixOrder = { + MATRIXORDER_COLUMN_MAJOR: 0, + MATRIXORDER_ROW_MAJOR: 1 + }; + + /** + * @param {gluVarType.MatrixOrder} qualifier + * @return {string} + */ + gluVarType.getMatrixOrderName = function(qualifier) { + switch (qualifier) { + case gluVarType.MatrixOrder.MATRIXORDER_COLUMN_MAJOR: return 'column_major'; + case gluVarType.MatrixOrder.MATRIXORDER_ROW_MAJOR: return 'row_major'; + default: + throw new Error('Unknown qualifier: ' + qualifier); + } + }; + + gluVarType.MemoryAccessQualifier = { + MEMORYACCESSQUALIFIER_COHERENT_BIT: 0x01, + MEMORYACCESSQUALIFIER_VOLATILE_BIT: 0x02, + MEMORYACCESSQUALIFIER_RESTRICT_BIT: 0x04, + MEMORYACCESSQUALIFIER_READONLY_BIT: 0x08, + MEMORYACCESSQUALIFIER_WRITEONLY_BIT: 0x10 + }; + gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_MASK = (gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_WRITEONLY_BIT << 1) - 1; + + /** + * @param {number} qualifier + * @return {string} + */ + gluVarType.getMemoryAccessQualifierName = function(qualifier) { + switch (qualifier) { + case gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_COHERENT_BIT: return 'coherent'; + case gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_VOLATILE_BIT: return 'volatile'; + case gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_RESTRICT_BIT: return 'restrict'; + case gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_READONLY_BIT: return 'readonly'; + case gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_WRITEONLY_BIT: return 'writeonly'; + default: + throw new Error('Unknown qualifier: ' + qualifier); + } + }; + + /** + * @constructor + * @param {number=} location + * @param {number=} binding + * @param {number=} offset + * @param {gluVarType.FormatLayout=} format + * @param {gluVarType.MatrixOrder=} matrixOrder + */ + gluVarType.Layout = function(location, binding, offset, format, matrixOrder) { + this.location = location; + this.binding = binding; + this.offset = offset; + this.format = format; + this.matrixOrder = matrixOrder; + }; + + gluVarType.Layout.prototype.toString = function() { + var strings = []; + var str = ''; + if (typeof this.location !== 'undefined') + strings.push('location=' + this.location); + if (typeof this.binding !== 'undefined') + strings.push('binding=' + this.binding); + if (typeof this.offset !== 'undefined') + strings.push('offset=' + this.offset); + if (typeof this.format !== 'undefined') + strings.push(gluVarType.getFormatLayoutName(this.format)); + if (typeof this.matrixOrder !== 'undefined') + strings.push(gluVarType.getMatrixOrderName(this.matrixOrder)); + + if (strings.length > 0) { + str += 'layout(' + strings[0]; + + for (var i = 1; i < strings.length; i++) + str += ', ' + strings[i]; + str += ')'; + } + + return str; + }; + + /** + * @constructor + * @param {gluVarType.VarType} varType + * @param {string} name + * @param {gluVarType.Storage=} storage + * @param {gluVarType.Interpolation=} interpolation + * @param {gluVarType.Layout=} layout + * @param {number=} memoryAccessQualifierBits + */ + gluVarType.VariableDeclaration = function(varType, name, storage, interpolation, layout, memoryAccessQualifierBits) { + this.varType = varType; + this.name = name; + this.storage = storage; + this.interpolation = interpolation; + this.layout = layout; + this.memoryAccessQualifierBits = memoryAccessQualifierBits || 0; + }; + + gluVarType.VariableDeclaration.prototype.toString = function() { + var str = ''; + if (typeof this.layout !== 'undefined') + str += this.layout.toString() + ' '; + + for (var bitNdx = 0; (1 << bitNdx) & gluVarType.MemoryAccessQualifier.MEMORYACCESSQUALIFIER_MASK; ++bitNdx) + if (this.memoryAccessQualifierBits & (1 << bitNdx)) + str += gluVarType.getMemoryAccessQualifierName((1 << bitNdx)) + ' '; + + if (typeof this.interpolation !== 'undefined') + str += gluVarType.getInterpolationName(this.interpolation) + ' '; + + if (typeof this.storage !== 'undefined') + str += gluVarType.getStorageName(this.storage) + ' '; + + str += gluVarType.declareVariable(this.varType, this.name); + + return str; + }; + +}); |