#ifndef _GLUVARTYPEUTIL_HPP
|
#define _GLUVARTYPEUTIL_HPP
|
/*-------------------------------------------------------------------------
|
* 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 utilities.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuDefs.hpp"
|
#include "gluVarType.hpp"
|
|
#include <vector>
|
#include <string>
|
#include <iterator>
|
|
namespace glu
|
{
|
|
// Variable path tokenizer
|
|
class VarTokenizer
|
{
|
public:
|
enum Token
|
{
|
TOKEN_IDENTIFIER = 0,
|
TOKEN_LEFT_BRACKET,
|
TOKEN_RIGHT_BRACKET,
|
TOKEN_PERIOD,
|
TOKEN_NUMBER,
|
TOKEN_END,
|
|
TOKEN_LAST
|
};
|
|
VarTokenizer (const char* str);
|
~VarTokenizer (void) {}
|
|
Token getToken (void) const { return m_token; }
|
std::string getIdentifier (void) const { return std::string(m_str+m_tokenStart, m_str+m_tokenStart+m_tokenLen); }
|
int getNumber (void) const;
|
int getCurrentTokenStartLocation (void) const { return m_tokenStart; }
|
int getCurrentTokenEndLocation (void) const { return m_tokenStart + m_tokenLen; }
|
void advance (void);
|
|
private:
|
const char* m_str;
|
|
Token m_token;
|
int m_tokenStart;
|
int m_tokenLen;
|
};
|
|
// VarType subtype path utilities.
|
|
struct VarTypeComponent
|
{
|
enum Type
|
{
|
STRUCT_MEMBER = 0,
|
ARRAY_ELEMENT,
|
MATRIX_COLUMN,
|
VECTOR_COMPONENT,
|
|
TYPE_LAST
|
};
|
|
VarTypeComponent (Type type_, int index_) : type(type_), index(index_) {}
|
VarTypeComponent (void) : type(TYPE_LAST), index(0) {}
|
|
bool operator== (const VarTypeComponent& other) const { return type == other.type && index == other.index; }
|
bool operator!= (const VarTypeComponent& other) const { return type != other.type || index != other.index; }
|
|
Type type;
|
int index;
|
};
|
|
typedef std::vector<VarTypeComponent> TypeComponentVector;
|
|
// TypeComponentVector utilties.
|
|
template <typename Iterator>
|
bool isValidTypePath (const VarType& type, Iterator begin, Iterator end);
|
|
template <typename Iterator>
|
VarType getVarType (const VarType& type, Iterator begin, Iterator end);
|
|
inline bool isValidTypePath (const VarType& type, const TypeComponentVector& path) { return isValidTypePath(type, path.begin(), path.end()); }
|
inline VarType getVarType (const VarType& type, const TypeComponentVector& path) { return getVarType(type, path.begin(), path.end()); }
|
|
std::string parseVariableName (const char* nameWithPath);
|
void parseTypePath (const char* nameWithPath, const VarType& type, TypeComponentVector& path);
|
|
// Type path formatter.
|
|
struct TypeAccessFormat
|
{
|
TypeAccessFormat (const VarType& type_, const TypeComponentVector& path_) : type(type_), path(path_) {}
|
|
const VarType& type;
|
const TypeComponentVector& path;
|
};
|
|
std::ostream& operator<< (std::ostream& str, const TypeAccessFormat& format);
|
|
// Subtype path builder.
|
|
class SubTypeAccess
|
{
|
public:
|
SubTypeAccess (const VarType& type);
|
|
SubTypeAccess& member (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::STRUCT_MEMBER, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access struct element.
|
SubTypeAccess& element (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::ARRAY_ELEMENT, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access array element.
|
SubTypeAccess& column (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::MATRIX_COLUMN, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access column.
|
SubTypeAccess& component (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::VECTOR_COMPONENT, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access component.
|
SubTypeAccess& parent (void) { DE_ASSERT(!m_path.empty()); m_path.pop_back(); return *this; }
|
|
SubTypeAccess member (int ndx) const { return SubTypeAccess(*this).member(ndx); }
|
SubTypeAccess element (int ndx) const { return SubTypeAccess(*this).element(ndx); }
|
SubTypeAccess column (int ndx) const { return SubTypeAccess(*this).column(ndx); }
|
SubTypeAccess component (int ndx) const { return SubTypeAccess(*this).component(ndx); }
|
SubTypeAccess parent (void) const { return SubTypeAccess(*this).parent(); }
|
|
bool isValid (void) const { return isValidTypePath(m_type, m_path); }
|
VarType getType (void) const { return getVarType(m_type, m_path); }
|
const TypeComponentVector& getPath (void) const { return m_path; }
|
|
bool empty (void) const { return m_path.empty(); }
|
|
bool operator== (const SubTypeAccess& other) const { return m_path == other.m_path && m_type == other.m_type; }
|
bool operator!= (const SubTypeAccess& other) const { return m_path != other.m_path || m_type != other.m_type; }
|
|
private:
|
VarType m_type;
|
TypeComponentVector m_path;
|
};
|
|
// Subtype iterator.
|
|
// \note VarType must be live during iterator usage.
|
template <class IsExpanded>
|
class SubTypeIterator : public std::iterator<std::forward_iterator_tag, VarType>
|
{
|
public:
|
static SubTypeIterator<IsExpanded> begin (const VarType* type) { return SubTypeIterator(type); }
|
static SubTypeIterator<IsExpanded> end (const VarType* type) { DE_UNREF(type); return SubTypeIterator(DE_NULL); }
|
|
bool operator== (const SubTypeIterator<IsExpanded>& other) const { return m_type == other.m_type && m_path == other.m_path; }
|
bool operator!= (const SubTypeIterator<IsExpanded>& other) const { return m_type != other.m_type || m_path != other.m_path; }
|
|
SubTypeIterator<IsExpanded>& operator++ (void);
|
SubTypeIterator<IsExpanded> operator++ (int) { SubTypeIterator<IsExpanded> copy(*this); ++(*this); return copy; }
|
|
void toStream (std::ostream& str) const { str << TypeAccessFormat(*m_type, m_path); }
|
VarType getType (void) const { return getVarType(*m_type, m_path.begin(), m_path.end()); }
|
const TypeComponentVector& getPath (void) const { return m_path; }
|
|
VarType operator* (void) const { return getType(); }
|
|
private:
|
SubTypeIterator (const VarType* type);
|
|
void removeTraversed (void);
|
void findNext (void);
|
|
const VarType* m_type;
|
TypeComponentVector m_path;
|
};
|
|
struct IsBasicType { bool operator() (const VarType& type) const { return type.isBasicType(); } };
|
struct IsScalarType { bool operator() (const VarType& type) const { return type.isBasicType() && isDataTypeScalar(type.getBasicType()); } };
|
struct IsVectorOrScalarType { bool operator() (const VarType& type) const { return type.isBasicType() && isDataTypeScalarOrVector(type.getBasicType()); } };
|
|
typedef SubTypeIterator<IsBasicType> BasicTypeIterator;
|
typedef SubTypeIterator<IsVectorOrScalarType> VectorTypeIterator;
|
typedef SubTypeIterator<IsScalarType> ScalarTypeIterator;
|
|
template <class IsExpanded>
|
std::ostream& operator<< (std::ostream& str, const SubTypeIterator<IsExpanded>& iter)
|
{
|
iter.toStream(str);
|
return str;
|
}
|
|
template <class IsExpanded>
|
SubTypeIterator<IsExpanded>::SubTypeIterator (const VarType* type)
|
: m_type(type)
|
{
|
if (m_type)
|
findNext();
|
}
|
|
template <class IsExpanded>
|
SubTypeIterator<IsExpanded>& SubTypeIterator<IsExpanded>::operator++ (void)
|
{
|
if (!m_path.empty())
|
{
|
// Remove traversed nodes.
|
removeTraversed();
|
|
if (!m_path.empty())
|
findNext();
|
else
|
m_type = DE_NULL; // Unset type to signal end.
|
}
|
else
|
{
|
// First type was already expanded.
|
DE_ASSERT(IsExpanded()(getVarType(*m_type, m_path)));
|
m_type = DE_NULL;
|
}
|
|
return *this;
|
}
|
|
template <class IsExpanded>
|
void SubTypeIterator<IsExpanded>::removeTraversed (void)
|
{
|
DE_ASSERT(m_type && !m_path.empty());
|
|
// Pop traversed nodes.
|
while (!m_path.empty())
|
{
|
VarTypeComponent& curComp = m_path.back();
|
VarType parentType = getVarType(*m_type, m_path.begin(), m_path.end()-1);
|
|
if (curComp.type == VarTypeComponent::MATRIX_COLUMN)
|
{
|
DE_ASSERT(isDataTypeMatrix(parentType.getBasicType()));
|
if (curComp.index+1 < getDataTypeMatrixNumColumns(parentType.getBasicType()))
|
break;
|
}
|
else if (curComp.type == VarTypeComponent::VECTOR_COMPONENT)
|
{
|
DE_ASSERT(isDataTypeVector(parentType.getBasicType()));
|
if (curComp.index+1 < getDataTypeScalarSize(parentType.getBasicType()))
|
break;
|
}
|
else if (curComp.type == VarTypeComponent::ARRAY_ELEMENT)
|
{
|
DE_ASSERT(parentType.isArrayType());
|
if (curComp.index+1 < parentType.getArraySize())
|
break;
|
}
|
else if (curComp.type == VarTypeComponent::STRUCT_MEMBER)
|
{
|
DE_ASSERT(parentType.isStructType());
|
if (curComp.index+1 < parentType.getStructPtr()->getNumMembers())
|
break;
|
}
|
|
m_path.pop_back();
|
}
|
}
|
|
template <class IsExpanded>
|
void SubTypeIterator<IsExpanded>::findNext (void)
|
{
|
if (!m_path.empty())
|
{
|
// Increment child counter in current level.
|
VarTypeComponent& curComp = m_path.back();
|
curComp.index += 1;
|
}
|
|
for (;;)
|
{
|
VarType curType = getVarType(*m_type, m_path);
|
|
if (IsExpanded()(curType))
|
break;
|
|
// Recurse into child type.
|
if (curType.isBasicType())
|
{
|
DataType basicType = curType.getBasicType();
|
|
if (isDataTypeMatrix(basicType))
|
m_path.push_back(VarTypeComponent(VarTypeComponent::MATRIX_COLUMN, 0));
|
else if (isDataTypeVector(basicType))
|
m_path.push_back(VarTypeComponent(VarTypeComponent::VECTOR_COMPONENT, 0));
|
else
|
DE_ASSERT(false); // Can't expand scalars - IsExpanded() is buggy.
|
}
|
else if (curType.isArrayType())
|
m_path.push_back(VarTypeComponent(VarTypeComponent::ARRAY_ELEMENT, 0));
|
else if (curType.isStructType())
|
m_path.push_back(VarTypeComponent(VarTypeComponent::STRUCT_MEMBER, 0));
|
else
|
DE_ASSERT(false);
|
}
|
}
|
|
template <typename Iterator>
|
bool isValidTypePath (const VarType& type, Iterator begin, Iterator end)
|
{
|
const VarType* curType = &type;
|
Iterator pathIter = begin;
|
|
// Process struct member and array element parts of path.
|
while (pathIter != end)
|
{
|
if (pathIter->type == VarTypeComponent::STRUCT_MEMBER)
|
{
|
if (!curType->isStructType() || !de::inBounds(pathIter->index, 0, curType->getStructPtr()->getNumMembers()))
|
return false;
|
|
curType = &curType->getStructPtr()->getMember(pathIter->index).getType();
|
}
|
else if (pathIter->type == VarTypeComponent::ARRAY_ELEMENT)
|
{
|
if (!curType->isArrayType() || (curType->getArraySize() != VarType::UNSIZED_ARRAY && !de::inBounds(pathIter->index, 0, curType->getArraySize())))
|
return false;
|
|
curType = &curType->getElementType();
|
}
|
else
|
break;
|
|
++pathIter;
|
}
|
|
if (pathIter != end)
|
{
|
DE_ASSERT(pathIter->type == VarTypeComponent::MATRIX_COLUMN || pathIter->type == VarTypeComponent::VECTOR_COMPONENT);
|
|
// Current type should be basic type.
|
if (!curType->isBasicType())
|
return false;
|
|
DataType basicType = curType->getBasicType();
|
|
if (pathIter->type == VarTypeComponent::MATRIX_COLUMN)
|
{
|
if (!isDataTypeMatrix(basicType))
|
return false;
|
|
basicType = getDataTypeFloatVec(getDataTypeMatrixNumRows(basicType));
|
++pathIter;
|
}
|
|
if (pathIter != end && pathIter->type == VarTypeComponent::VECTOR_COMPONENT)
|
{
|
if (!isDataTypeVector(basicType))
|
return false;
|
|
basicType = getDataTypeScalarType(basicType);
|
++pathIter;
|
}
|
}
|
|
return pathIter == end;
|
}
|
|
template <typename Iterator>
|
VarType getVarType (const VarType& type, Iterator begin, Iterator end)
|
{
|
TCU_CHECK(isValidTypePath(type, begin, end));
|
|
const VarType* curType = &type;
|
Iterator pathIter = begin;
|
|
// Process struct member and array element parts of path.
|
while (pathIter != end)
|
{
|
if (pathIter->type == VarTypeComponent::STRUCT_MEMBER)
|
curType = &curType->getStructPtr()->getMember(pathIter->index).getType();
|
else if (pathIter->type == VarTypeComponent::ARRAY_ELEMENT)
|
curType = &curType->getElementType();
|
else
|
break;
|
|
++pathIter;
|
}
|
|
if (pathIter != end)
|
{
|
DataType basicType = curType->getBasicType();
|
Precision precision = curType->getPrecision();
|
|
if (pathIter->type == VarTypeComponent::MATRIX_COLUMN)
|
{
|
basicType = getDataTypeFloatVec(getDataTypeMatrixNumRows(basicType));
|
++pathIter;
|
}
|
|
if (pathIter != end && pathIter->type == VarTypeComponent::VECTOR_COMPONENT)
|
{
|
basicType = getDataTypeScalarType(basicType);
|
++pathIter;
|
}
|
|
DE_ASSERT(pathIter == end);
|
return VarType(basicType, precision);
|
}
|
else
|
return VarType(*curType);
|
}
|
|
} // glu
|
|
#endif // _GLUVARTYPEUTIL_HPP
|
