#ifndef _GLUVARTYPE_HPP
|
#define _GLUVARTYPE_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.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuDefs.hpp"
|
#include "gluShaderUtil.hpp"
|
|
#include <vector>
|
#include <string>
|
#include <ostream>
|
|
namespace glu
|
{
|
|
class StructType;
|
|
/*--------------------------------------------------------------------*//*!
|
* \brief Shader variable type.
|
*
|
* Variable type represents data type. No storage qualifiers are supported
|
* since they are associated to a declaration, not to the variable type.
|
*
|
* \note Structs are handled using struct pointers since it is often desirable
|
* to maintain unique list of struct declarations.
|
*//*--------------------------------------------------------------------*/
|
class VarType
|
{
|
public:
|
VarType (void);
|
VarType (const VarType& other);
|
|
VarType (DataType basicType, Precision precision); //!< Basic type constructor.
|
VarType (const VarType& elementType, int arraySize); //!< Array type constructor.
|
explicit VarType (const StructType* structPtr); //!< Struct type constructor.
|
~VarType (void);
|
|
bool isBasicType (void) const { return m_type == TYPE_BASIC; }
|
bool isArrayType (void) const { return m_type == TYPE_ARRAY; }
|
bool isStructType (void) const { return m_type == TYPE_STRUCT; }
|
|
DataType getBasicType (void) const { DE_ASSERT(isBasicType()); return m_data.basic.type; }
|
Precision getPrecision (void) const { DE_ASSERT(isBasicType()); return m_data.basic.precision; }
|
|
const VarType& getElementType (void) const { DE_ASSERT(isArrayType()); return *m_data.array.elementType; }
|
int getArraySize (void) const { DE_ASSERT(isArrayType()); return m_data.array.size; }
|
|
const StructType* getStructPtr (void) const { DE_ASSERT(isStructType()); return m_data.structPtr; }
|
|
int getScalarSize (void) const;
|
|
VarType& operator= (const VarType& other);
|
|
bool operator== (const VarType& other) const;
|
bool operator!= (const VarType& other) const;
|
|
enum
|
{
|
UNSIZED_ARRAY = -1 //!< Array length for unsized arrays.
|
};
|
|
private:
|
enum Type
|
{
|
TYPE_BASIC,
|
TYPE_ARRAY,
|
TYPE_STRUCT,
|
|
TYPE_LAST
|
};
|
|
Type m_type;
|
union Data
|
{
|
// TYPE_BASIC
|
struct
|
{
|
DataType type;
|
Precision precision;
|
} basic;
|
|
// TYPE_ARRAY
|
struct
|
{
|
VarType* elementType;
|
int size;
|
} array;
|
|
// TYPE_STRUCT
|
const StructType* structPtr;
|
|
Data (void)
|
{
|
array.elementType = DE_NULL;
|
array.size = 0;
|
};
|
} m_data;
|
} DE_WARN_UNUSED_TYPE;
|
|
template <typename T>
|
inline VarType varTypeOf (Precision prec = PRECISION_LAST) { return VarType(dataTypeOf<T>(), prec); }
|
|
class StructMember
|
{
|
public:
|
StructMember (const char* name, const VarType& type) : m_name(name), m_type(type) {}
|
StructMember (void) {}
|
|
const char* getName (void) const { return m_name.c_str(); }
|
const VarType& getType (void) const { return m_type; }
|
|
bool operator== (const StructMember& other) const;
|
bool operator!= (const StructMember& other) const;
|
|
private:
|
std::string m_name;
|
VarType m_type;
|
} DE_WARN_UNUSED_TYPE;
|
|
class StructType
|
{
|
public:
|
typedef std::vector<StructMember>::iterator Iterator;
|
typedef std::vector<StructMember>::const_iterator ConstIterator;
|
|
StructType (const char* typeName) : m_typeName(typeName) {}
|
~StructType (void) {}
|
|
bool hasTypeName (void) const { return !m_typeName.empty(); }
|
const char* getTypeName (void) const { return hasTypeName() ? m_typeName.c_str() : DE_NULL; }
|
|
void addMember (const char* name, const VarType& type);
|
|
int getNumMembers (void) const { return (int)m_members.size(); }
|
const StructMember& getMember (int ndx) const { return m_members[ndx]; }
|
|
inline Iterator begin (void) { return m_members.begin(); }
|
inline ConstIterator begin (void) const { return m_members.begin(); }
|
inline Iterator end (void) { return m_members.end(); }
|
inline ConstIterator end (void) const { return m_members.end(); }
|
|
bool operator== (const StructType& other) const;
|
bool operator!= (const StructType& other) const;
|
|
private:
|
std::string m_typeName;
|
std::vector<StructMember> m_members;
|
} DE_WARN_UNUSED_TYPE;
|
|
enum Storage
|
{
|
STORAGE_IN = 0,
|
STORAGE_OUT,
|
STORAGE_CONST,
|
STORAGE_UNIFORM,
|
STORAGE_BUFFER,
|
STORAGE_PATCH_IN,
|
STORAGE_PATCH_OUT,
|
STORAGE_LAST
|
};
|
|
const char* getStorageName (Storage storage);
|
|
enum Interpolation
|
{
|
INTERPOLATION_SMOOTH = 0,
|
INTERPOLATION_FLAT,
|
INTERPOLATION_CENTROID,
|
INTERPOLATION_LAST
|
};
|
|
const char* getInterpolationName (Interpolation interpolation);
|
|
enum FormatLayout
|
{
|
FORMATLAYOUT_RGBA32F = 0,
|
FORMATLAYOUT_RGBA16F,
|
FORMATLAYOUT_R32F,
|
FORMATLAYOUT_RGBA8,
|
FORMATLAYOUT_RGBA8_SNORM,
|
|
FORMATLAYOUT_RGBA32I,
|
FORMATLAYOUT_RGBA16I,
|
FORMATLAYOUT_RGBA8I,
|
FORMATLAYOUT_R32I,
|
|
FORMATLAYOUT_RGBA32UI,
|
FORMATLAYOUT_RGBA16UI,
|
FORMATLAYOUT_RGBA8UI,
|
FORMATLAYOUT_R32UI,
|
|
FORMATLAYOUT_LAST
|
};
|
|
const char* getFormatLayoutName (FormatLayout layout);
|
|
enum MemoryAccessQualifier
|
{
|
MEMORYACCESSQUALIFIER_COHERENT_BIT = 0x01,
|
MEMORYACCESSQUALIFIER_VOLATILE_BIT = 0x02,
|
MEMORYACCESSQUALIFIER_RESTRICT_BIT = 0x04,
|
MEMORYACCESSQUALIFIER_READONLY_BIT = 0x08,
|
MEMORYACCESSQUALIFIER_WRITEONLY_BIT = 0x10,
|
|
MEMORYACCESSQUALIFIER_MASK = (MEMORYACCESSQUALIFIER_WRITEONLY_BIT << 1) - 1
|
};
|
|
const char* getMemoryAccessQualifierName (MemoryAccessQualifier qualifier);
|
|
enum MatrixOrder
|
{
|
MATRIXORDER_COLUMN_MAJOR = 0,
|
MATRIXORDER_ROW_MAJOR,
|
|
MATRIXORDER_LAST
|
};
|
|
const char* getMatrixOrderName (MatrixOrder qualifier);
|
|
// Declaration utilities.
|
|
struct Layout
|
{
|
Layout (int location_ = -1, int binding_ = -1, int offset_ = -1, FormatLayout format_ = FORMATLAYOUT_LAST, MatrixOrder matrixOrder_ = MATRIXORDER_LAST);
|
|
bool operator== (const Layout& other) const;
|
bool operator!= (const Layout& other) const;
|
|
int location;
|
int binding;
|
int offset;
|
FormatLayout format;
|
MatrixOrder matrixOrder;
|
} DE_WARN_UNUSED_TYPE;
|
|
struct VariableDeclaration
|
{
|
VariableDeclaration (const VarType& varType_, const std::string& name_, Storage storage_ = STORAGE_LAST, Interpolation interpolation_ = INTERPOLATION_LAST, const Layout& layout_ = Layout(), deUint32 memoryAccessQualifierBits_ = 0);
|
|
bool operator== (const VariableDeclaration& other) const;
|
bool operator!= (const VariableDeclaration& other) const;
|
|
Layout layout;
|
Interpolation interpolation;
|
Storage storage;
|
VarType varType;
|
deUint32 memoryAccessQualifierBits;
|
std::string name;
|
} DE_WARN_UNUSED_TYPE;
|
|
struct InterfaceBlock
|
{
|
InterfaceBlock (void);
|
|
glu::Layout layout;
|
Storage storage;
|
int memoryAccessQualifierFlags;
|
std::string interfaceName;
|
std::string instanceName;
|
std::vector<glu::VariableDeclaration> variables;
|
std::vector<int> dimensions;
|
} DE_WARN_UNUSED_TYPE;
|
|
//! Internals for declare() utilities.
|
namespace decl
|
{
|
|
struct Indent
|
{
|
int level;
|
Indent (int level_) : level(level_) {}
|
};
|
|
struct DeclareStructTypePtr
|
{
|
DeclareStructTypePtr (const StructType* structPtr_, int indentLevel_) : structPtr(structPtr_), indentLevel(indentLevel_) {}
|
|
const StructType* structPtr;
|
int indentLevel;
|
};
|
|
struct DeclareStructType
|
{
|
DeclareStructType (const StructType& structType_, int indentLevel_) : structType(structType_), indentLevel(indentLevel_) {}
|
|
StructType structType;
|
int indentLevel;
|
};
|
|
struct DeclareVariable
|
{
|
DeclareVariable (const VarType& varType_, const std::string& name_, int indentLevel_) : varType(varType_), name(name_), indentLevel(indentLevel_) {}
|
|
VarType varType;
|
std::string name;
|
int indentLevel;
|
};
|
|
std::ostream& operator<< (std::ostream& str, const Indent& indent);
|
std::ostream& operator<< (std::ostream& str, const DeclareStructTypePtr& decl);
|
std::ostream& operator<< (std::ostream& str, const DeclareStructType& decl);
|
std::ostream& operator<< (std::ostream& str, const DeclareVariable& decl);
|
|
} // decl
|
|
inline decl::Indent indent (int indentLevel) { return decl::Indent(indentLevel); }
|
inline decl::DeclareStructTypePtr declare (const StructType* structPtr, int indentLevel = 0) { return decl::DeclareStructTypePtr (structPtr, indentLevel); }
|
inline decl::DeclareStructType declare (const StructType& structType, int indentLevel = 0) { return decl::DeclareStructType (structType, indentLevel); }
|
inline decl::DeclareVariable declare (const VarType& varType, const std::string& name, int indentLevel = 0) { return decl::DeclareVariable (varType, name, indentLevel); }
|
|
std::ostream& operator<< (std::ostream& str, const Layout& decl);
|
std::ostream& operator<< (std::ostream& str, const VariableDeclaration& decl);
|
|
} // glu
|
|
#endif // _GLUVARTYPE_HPP
|
