/*-------------------------------------------------------------------------
* 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.
*
*//*!
* \file
* \brief Shader variable type.
*//*--------------------------------------------------------------------*/
#include "gluVarType.hpp"
#include "deStringUtil.hpp"
#include "deArrayUtil.hpp"
namespace glu
{
VarType::VarType (void)
: m_type(TYPE_LAST)
{
}
VarType::VarType (const VarType& other)
: m_type(TYPE_LAST)
{
*this = other;
}
VarType::VarType (DataType basicType, Precision precision)
: m_type(TYPE_BASIC)
{
m_data.basic.type = basicType;
m_data.basic.precision = precision;
}
VarType::VarType (const VarType& elementType, int arraySize)
: m_type(TYPE_ARRAY)
{
DE_ASSERT(arraySize >= 0 || arraySize == UNSIZED_ARRAY);
m_data.array.size = arraySize;
m_data.array.elementType = new VarType(elementType);
}
VarType::VarType (const StructType* structPtr)
: m_type(TYPE_STRUCT)
{
m_data.structPtr = structPtr;
}
VarType::~VarType (void)
{
if (m_type == TYPE_ARRAY)
delete m_data.array.elementType;
}
VarType& VarType::operator= (const VarType& other)
{
if (this == &other)
return *this; // Self-assignment.
if (m_type == TYPE_ARRAY)
delete m_data.array.elementType;
m_type = other.m_type;
m_data = Data();
if (m_type == TYPE_ARRAY)
{
m_data.array.elementType = new VarType(*other.m_data.array.elementType);
m_data.array.size = other.m_data.array.size;
}
else
m_data = other.m_data;
return *this;
}
int VarType::getScalarSize (void) const
{
switch (m_type)
{
case TYPE_BASIC: return glu::getDataTypeScalarSize(m_data.basic.type);
case TYPE_ARRAY: return m_data.array.elementType->getScalarSize()*m_data.array.size;
case TYPE_STRUCT:
{
int size = 0;
for (StructType::ConstIterator iter = m_data.structPtr->begin(); iter != m_data.structPtr->end(); iter++)
size += iter->getType().getScalarSize();
return size;
}
default:
DE_ASSERT(false);
return 0;
}
}
bool VarType::operator== (const VarType& other) const
{
if (m_type != other.m_type)
return false;
switch (m_type)
{
case TYPE_BASIC:
return m_data.basic.type == other.m_data.basic.type &&
m_data.basic.precision == other.m_data.basic.precision;
case TYPE_ARRAY:
return *m_data.array.elementType == *other.m_data.array.elementType &&
m_data.array.size == other.m_data.array.size;
case TYPE_STRUCT:
return m_data.structPtr == other.m_data.structPtr;
default:
DE_ASSERT(false);
return 0;
}
}
bool VarType::operator!= (const VarType& other) const
{
return !(*this == other);
}
// StructMember implementation
bool StructMember::operator== (const StructMember& other) const
{
return (m_name == other.m_name) && (m_type == other.m_type);
}
bool StructMember::operator!= (const StructMember& other) const
{
return !(*this == other);
}
// StructType implementation.
void StructType::addMember (const char* name, const VarType& type)
{
m_members.push_back(StructMember(name, type));
}
bool StructType::operator== (const StructType& other) const
{
return (m_typeName == other.m_typeName) && (m_members == other.m_members);
}
bool StructType::operator!= (const StructType& other) const
{
return !(*this == other);
}
const char* getStorageName (Storage storage)
{
static const char* const s_names[] = { "in", "out", "const", "uniform", "buffer", "patch in", "patch out" };
return de::getSizedArrayElement<STORAGE_LAST>(s_names, storage);
}
const char* getInterpolationName (Interpolation interpolation)
{
static const char* const s_names[] = { "smooth", "flat", "centroid" };
return de::getSizedArrayElement<INTERPOLATION_LAST>(s_names, interpolation);
}
const char* getFormatLayoutName (FormatLayout layout)
{
static const char* s_names[] =
{
"rgba32f", // FORMATLAYOUT_RGBA32F
"rgba16f", // FORMATLAYOUT_RGBA16F
"r32f", // FORMATLAYOUT_R32F
"rgba8", // FORMATLAYOUT_RGBA8
"rgba8_snorm", // FORMATLAYOUT_RGBA8_SNORM
"rgba32i", // FORMATLAYOUT_RGBA32I
"rgba16i", // FORMATLAYOUT_RGBA16I
"rgba8i", // FORMATLAYOUT_RGBA8I
"r32i", // FORMATLAYOUT_R32I
"rgba32ui", // FORMATLAYOUT_RGBA32UI
"rgba16ui", // FORMATLAYOUT_RGBA16UI
"rgba8ui", // FORMATLAYOUT_RGBA8UI
"r32ui", // FORMATLAYOUT_R32UI
};
return de::getSizedArrayElement<FORMATLAYOUT_LAST>(s_names, layout);
}
const char* getMemoryAccessQualifierName (MemoryAccessQualifier qualifier)
{
switch (qualifier)
{
case MEMORYACCESSQUALIFIER_COHERENT_BIT: return "coherent";
case MEMORYACCESSQUALIFIER_VOLATILE_BIT: return "volatile";
case MEMORYACCESSQUALIFIER_RESTRICT_BIT: return "restrict";
case MEMORYACCESSQUALIFIER_READONLY_BIT: return "readonly";
case MEMORYACCESSQUALIFIER_WRITEONLY_BIT: return "writeonly";
default:
DE_ASSERT(false);
return DE_NULL;
}
}
const char* getMatrixOrderName (MatrixOrder qualifier)
{
static const char* s_names[] =
{
"column_major", // MATRIXORDER_COLUMN_MAJOR
"row_major", // MATRIXORDER_ROW_MAJOR
};
return de::getSizedArrayElement<MATRIXORDER_LAST>(s_names, qualifier);
}
// Layout Implementation
Layout::Layout (int location_, int binding_, int offset_, FormatLayout format_, MatrixOrder matrixOrder_)
: location (location_)
, binding (binding_)
, offset (offset_)
, format (format_)
, matrixOrder (matrixOrder_)
{
}
bool Layout::operator== (const Layout& other) const
{
return location == other.location &&
binding == other.binding &&
offset == other.offset &&
format == other.format &&
matrixOrder == other.matrixOrder;
}
bool Layout::operator!= (const Layout& other) const
{
return !(*this == other);
}
// VariableDeclaration Implementation
VariableDeclaration::VariableDeclaration (const VarType& varType_, const std::string& name_, Storage storage_, Interpolation interpolation_, const Layout& layout_, deUint32 memoryAccessQualifierBits_)
: layout (layout_)
, interpolation (interpolation_)
, storage (storage_)
, varType (varType_)
, memoryAccessQualifierBits (memoryAccessQualifierBits_)
, name (name_)
{
}
bool VariableDeclaration::operator== (const VariableDeclaration& other) const
{
return layout == other.layout &&
interpolation == other.interpolation &&
storage == other.storage &&
varType == other.varType &&
memoryAccessQualifierBits == other.memoryAccessQualifierBits &&
name == other.name;
}
bool VariableDeclaration::operator!= (const VariableDeclaration& other) const
{
return !(*this == other);
}
// InterfaceBlock Implementation
InterfaceBlock::InterfaceBlock (void)
: layout (Layout())
, storage (glu::STORAGE_LAST)
, memoryAccessQualifierFlags (0)
{
}
// Declaration utilties.
std::ostream& operator<< (std::ostream& str, const Layout& layout)
{
std::vector<std::string> layoutDeclarationList;
if (layout.location != -1)
layoutDeclarationList.push_back("location=" + de::toString(layout.location));
if (layout.binding != -1)
layoutDeclarationList.push_back("binding=" + de::toString(layout.binding));
if (layout.offset != -1)
layoutDeclarationList.push_back("offset=" + de::toString(layout.offset));
if (layout.format != FORMATLAYOUT_LAST)
layoutDeclarationList.push_back(getFormatLayoutName(layout.format));
if (layout.matrixOrder != MATRIXORDER_LAST)
layoutDeclarationList.push_back(getMatrixOrderName(layout.matrixOrder));
if (!layoutDeclarationList.empty())
{
str << "layout(" << layoutDeclarationList[0];
for (int layoutNdx = 1; layoutNdx < (int)layoutDeclarationList.size(); ++layoutNdx)
str << ", " << layoutDeclarationList[layoutNdx];
str << ")";
}
return str;
}
std::ostream& operator<< (std::ostream& str, const VariableDeclaration& decl)
{
if (decl.layout != Layout())
str << decl.layout << " ";
for (int bitNdx = 0; (1 << bitNdx) & MEMORYACCESSQUALIFIER_MASK; ++bitNdx)
if (decl.memoryAccessQualifierBits & (1 << bitNdx))
str << getMemoryAccessQualifierName((glu::MemoryAccessQualifier)(1 << bitNdx)) << " ";
if (decl.interpolation != INTERPOLATION_LAST)
str << getInterpolationName(decl.interpolation) << " ";
if (decl.storage != STORAGE_LAST)
str << getStorageName(decl.storage) << " ";
str << declare(decl.varType, decl.name);
return str;
}
namespace decl
{
std::ostream& operator<< (std::ostream& str, const Indent& indent)
{
for (int i = 0; i < indent.level; i++)
str << "\t";
return str;
}
std::ostream& operator<< (std::ostream& str, const DeclareVariable& decl)
{
const VarType& type = decl.varType;
const VarType* curType = &type;
std::vector<int> arraySizes;
// Handle arrays.
while (curType->isArrayType())
{
arraySizes.push_back(curType->getArraySize());
curType = &curType->getElementType();
}
if (curType->isBasicType())
{
if (curType->getPrecision() != PRECISION_LAST)
str << glu::getPrecisionName(curType->getPrecision()) << " ";
str << glu::getDataTypeName(curType->getBasicType());
}
else if (curType->isStructType())
{
const StructType* structPtr = curType->getStructPtr();
if (structPtr->hasTypeName())
str << structPtr->getTypeName();
else
str << declare(structPtr, decl.indentLevel); // Generate inline declaration.
}
else
DE_ASSERT(false);
str << " " << decl.name;
// Print array sizes.
for (std::vector<int>::const_iterator sizeIter = arraySizes.begin(); sizeIter != arraySizes.end(); sizeIter++)
{
const int arrSize = *sizeIter;
if (arrSize == VarType::UNSIZED_ARRAY)
str << "[]";
else
str << "[" << arrSize << "]";
}
return str;
}
std::ostream& operator<< (std::ostream& str, const DeclareStructTypePtr& decl)
{
str << "struct";
// Type name is optional.
if (decl.structPtr->hasTypeName())
str << " " << decl.structPtr->getTypeName();
str << "\n" << indent(decl.indentLevel) << "{\n";
for (StructType::ConstIterator memberIter = decl.structPtr->begin(); memberIter != decl.structPtr->end(); memberIter++)
{
str << indent(decl.indentLevel+1);
str << declare(memberIter->getType(), memberIter->getName(), decl.indentLevel+1) << ";\n";
}
str << indent(decl.indentLevel) << "}";
return str;
}
std::ostream& operator<< (std::ostream& str, const DeclareStructType& decl)
{
return str << declare(&decl.structType, decl.indentLevel);
}
} // decl
} // glu