#ifndef _RSGVARIABLETYPE_HPP
|
#define _RSGVARIABLETYPE_HPP
|
/*-------------------------------------------------------------------------
|
* drawElements Quality Program Random Shader Generator
|
* ----------------------------------------------------
|
*
|
* 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 Variable Type class.
|
*//*--------------------------------------------------------------------*/
|
|
#include "rsgDefs.hpp"
|
|
#include <vector>
|
#include <string>
|
|
namespace rsg
|
{
|
|
class TokenStream;
|
|
class VariableType
|
{
|
public:
|
enum Type
|
{
|
TYPE_VOID = 0,
|
TYPE_FLOAT,
|
TYPE_INT,
|
TYPE_BOOL,
|
TYPE_STRUCT,
|
TYPE_ARRAY,
|
TYPE_SAMPLER_2D,
|
TYPE_SAMPLER_CUBE,
|
|
TYPE_LAST
|
};
|
|
enum Precision
|
{
|
PRECISION_NONE = 0,
|
PRECISION_LOW,
|
PRECISION_MEDIUM,
|
PRECISION_HIGH,
|
|
PRECISION_LAST
|
};
|
|
class Member
|
{
|
public:
|
Member (void)
|
: m_type(DE_NULL)
|
, m_name()
|
{
|
}
|
|
Member (const VariableType& type, const char* name)
|
: m_type(new VariableType(type))
|
, m_name(name)
|
{
|
}
|
|
~Member (void)
|
{
|
delete m_type;
|
}
|
|
Member (const Member& other)
|
: m_type(DE_NULL)
|
, m_name(other.m_name)
|
{
|
if (other.m_type)
|
m_type = new VariableType(*other.m_type);
|
}
|
|
Member& operator= (const Member& other)
|
{
|
if (this == &other)
|
return *this;
|
|
delete m_type;
|
|
m_type = DE_NULL;
|
m_name = other.m_name;
|
|
if (other.m_type)
|
m_type = new VariableType(*other.m_type);
|
|
return *this;
|
}
|
|
bool operator!= (const Member& other) const
|
{
|
if (m_name != other.m_name)
|
return true;
|
if (!!m_type != !!other.m_type)
|
return true;
|
if (m_type && *m_type != *other.m_type)
|
return true;
|
return false;
|
}
|
|
bool operator== (const Member& other) const
|
{
|
return !(*this != other);
|
}
|
|
const VariableType& getType (void) const { return *m_type; }
|
const char* getName (void) const { return m_name.c_str(); }
|
|
private:
|
VariableType* m_type;
|
std::string m_name;
|
};
|
|
VariableType (void);
|
VariableType (Type baseType, int numElements = 0);
|
VariableType (Type baseType, const VariableType& elementType, int numElements);
|
VariableType (Type baseType, const char* typeName);
|
~VariableType (void);
|
|
Type getBaseType (void) const { return m_baseType; }
|
Precision getPrecision (void) const { return m_precision; }
|
const char* getTypeName (void) const { return m_typeName.c_str(); }
|
int getNumElements (void) const { return m_numElements; }
|
const VariableType& getElementType (void) const;
|
|
const std::vector<Member>& getMembers (void) const { return m_members; }
|
std::vector<Member>& getMembers (void) { return m_members; }
|
|
int getScalarSize (void) const;
|
int getElementScalarOffset (int elementNdx) const;
|
int getMemberScalarOffset (int memberNdx) const;
|
|
bool operator!= (const VariableType& other) const;
|
bool operator== (const VariableType& other) const;
|
|
VariableType& operator= (const VariableType& other);
|
VariableType (const VariableType& other);
|
|
void tokenizeShortType (TokenStream& str) const;
|
|
bool isStruct (void) const { return m_baseType == TYPE_STRUCT; }
|
bool isArray (void) const { return m_baseType == TYPE_ARRAY; }
|
bool isFloatOrVec (void) const { return m_baseType == TYPE_FLOAT; }
|
bool isIntOrVec (void) const { return m_baseType == TYPE_INT; }
|
bool isBoolOrVec (void) const { return m_baseType == TYPE_BOOL; }
|
bool isSampler (void) const { return m_baseType == TYPE_SAMPLER_2D || m_baseType == TYPE_SAMPLER_CUBE; }
|
bool isVoid (void) const { return m_baseType == TYPE_VOID; }
|
|
static const VariableType& getScalarType (Type baseType);
|
|
private:
|
Type m_baseType;
|
Precision m_precision;
|
std::string m_typeName;
|
int m_numElements;
|
VariableType* m_elementType;
|
std::vector<Member> m_members;
|
};
|
|
inline VariableType::VariableType (void)
|
: m_baseType (TYPE_VOID)
|
, m_precision (PRECISION_NONE)
|
, m_typeName ()
|
, m_numElements (0)
|
, m_elementType (DE_NULL)
|
{
|
}
|
|
inline VariableType::VariableType (Type baseType, int numElements)
|
: m_baseType (baseType)
|
, m_precision (PRECISION_NONE)
|
, m_typeName ()
|
, m_numElements (numElements)
|
, m_elementType (DE_NULL)
|
{
|
DE_ASSERT(baseType != TYPE_ARRAY && baseType != TYPE_STRUCT);
|
}
|
|
inline VariableType::VariableType (Type baseType, const VariableType& elementType, int numElements)
|
: m_baseType (baseType)
|
, m_precision (PRECISION_NONE)
|
, m_typeName ()
|
, m_numElements (numElements)
|
, m_elementType (new VariableType(elementType))
|
{
|
DE_ASSERT(baseType == TYPE_ARRAY);
|
}
|
|
inline VariableType::VariableType (Type baseType, const char* typeName)
|
: m_baseType (baseType)
|
, m_precision (PRECISION_NONE)
|
, m_typeName (typeName)
|
, m_numElements (0)
|
, m_elementType (DE_NULL)
|
{
|
DE_ASSERT(baseType == TYPE_STRUCT);
|
}
|
|
inline VariableType::~VariableType (void)
|
{
|
delete m_elementType;
|
}
|
|
} // rsg
|
|
#endif // _RSGVARIABLETYPE_HPP
|
