| #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; |
| } |
| |
| } // namespace rsg |
| |
| #endif // _RSGVARIABLETYPE_HPP |