1 #ifndef _GLUVARTYPEUTIL_HPP 2 #define _GLUVARTYPEUTIL_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program OpenGL ES Utilities 5 * ------------------------------------------------ 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Shader variable type utilities. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "gluVarType.hpp" 28 29 #include <vector> 30 #include <string> 31 #include <iterator> 32 33 namespace glu 34 { 35 36 // Variable path tokenizer 37 38 class VarTokenizer 39 { 40 public: 41 enum Token 42 { 43 TOKEN_IDENTIFIER = 0, 44 TOKEN_LEFT_BRACKET, 45 TOKEN_RIGHT_BRACKET, 46 TOKEN_PERIOD, 47 TOKEN_NUMBER, 48 TOKEN_END, 49 50 TOKEN_LAST 51 }; 52 53 VarTokenizer (const char* str); 54 ~VarTokenizer (void) {} 55 56 Token getToken (void) const { return m_token; } 57 std::string getIdentifier (void) const { return std::string(m_str+m_tokenStart, m_str+m_tokenStart+m_tokenLen); } 58 int getNumber (void) const; 59 int getCurrentTokenStartLocation (void) const { return m_tokenStart; } 60 int getCurrentTokenEndLocation (void) const { return m_tokenStart + m_tokenLen; } 61 void advance (void); 62 63 private: 64 const char* m_str; 65 66 Token m_token; 67 int m_tokenStart; 68 int m_tokenLen; 69 }; 70 71 // VarType subtype path utilities. 72 73 struct VarTypeComponent 74 { 75 enum Type 76 { 77 STRUCT_MEMBER = 0, 78 ARRAY_ELEMENT, 79 MATRIX_COLUMN, 80 VECTOR_COMPONENT, 81 82 TYPE_LAST 83 }; 84 85 VarTypeComponent (Type type_, int index_) : type(type_), index(index_) {} 86 VarTypeComponent (void) : type(TYPE_LAST), index(0) {} 87 88 bool operator== (const VarTypeComponent& other) const { return type == other.type && index == other.index; } 89 bool operator!= (const VarTypeComponent& other) const { return type != other.type || index != other.index; } 90 91 Type type; 92 int index; 93 }; 94 95 typedef std::vector<VarTypeComponent> TypeComponentVector; 96 97 // TypeComponentVector utilties. 98 99 template <typename Iterator> 100 bool isValidTypePath (const VarType& type, Iterator begin, Iterator end); 101 102 template <typename Iterator> 103 VarType getVarType (const VarType& type, Iterator begin, Iterator end); 104 105 inline bool isValidTypePath (const VarType& type, const TypeComponentVector& path) { return isValidTypePath(type, path.begin(), path.end()); } 106 inline VarType getVarType (const VarType& type, const TypeComponentVector& path) { return getVarType(type, path.begin(), path.end()); } 107 108 std::string parseVariableName (const char* nameWithPath); 109 void parseTypePath (const char* nameWithPath, const VarType& type, TypeComponentVector& path); 110 111 // Type path formatter. 112 113 struct TypeAccessFormat 114 { 115 TypeAccessFormat (const VarType& type_, const TypeComponentVector& path_) : type(type_), path(path_) {} 116 117 const VarType& type; 118 const TypeComponentVector& path; 119 }; 120 121 std::ostream& operator<< (std::ostream& str, const TypeAccessFormat& format); 122 123 // Subtype path builder. 124 125 class SubTypeAccess 126 { 127 public: 128 SubTypeAccess (const VarType& type); 129 130 SubTypeAccess& member (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::STRUCT_MEMBER, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access struct element. 131 SubTypeAccess& element (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::ARRAY_ELEMENT, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access array element. 132 SubTypeAccess& column (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::MATRIX_COLUMN, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access column. 133 SubTypeAccess& component (int ndx) { m_path.push_back(VarTypeComponent(VarTypeComponent::VECTOR_COMPONENT, ndx)); DE_ASSERT(isValid()); return *this; } //!< Access component. 134 SubTypeAccess& parent (void) { DE_ASSERT(!m_path.empty()); m_path.pop_back(); return *this; } 135 136 SubTypeAccess member (int ndx) const { return SubTypeAccess(*this).member(ndx); } 137 SubTypeAccess element (int ndx) const { return SubTypeAccess(*this).element(ndx); } 138 SubTypeAccess column (int ndx) const { return SubTypeAccess(*this).column(ndx); } 139 SubTypeAccess component (int ndx) const { return SubTypeAccess(*this).component(ndx); } 140 SubTypeAccess parent (void) const { return SubTypeAccess(*this).parent(); } 141 142 bool isValid (void) const { return isValidTypePath(m_type, m_path); } 143 VarType getType (void) const { return getVarType(m_type, m_path); } 144 const TypeComponentVector& getPath (void) const { return m_path; } 145 146 bool empty (void) const { return m_path.empty(); } 147 148 bool operator== (const SubTypeAccess& other) const { return m_path == other.m_path && m_type == other.m_type; } 149 bool operator!= (const SubTypeAccess& other) const { return m_path != other.m_path || m_type != other.m_type; } 150 151 private: 152 VarType m_type; 153 TypeComponentVector m_path; 154 }; 155 156 // Subtype iterator. 157 158 // \note VarType must be live during iterator usage. 159 template <class IsExpanded> 160 class SubTypeIterator : public std::iterator<std::forward_iterator_tag, VarType> 161 { 162 public: 163 static SubTypeIterator<IsExpanded> begin (const VarType* type) { return SubTypeIterator(type); } 164 static SubTypeIterator<IsExpanded> end (const VarType* type) { DE_UNREF(type); return SubTypeIterator(DE_NULL); } 165 166 bool operator== (const SubTypeIterator<IsExpanded>& other) const { return m_type == other.m_type && m_path == other.m_path; } 167 bool operator!= (const SubTypeIterator<IsExpanded>& other) const { return m_type != other.m_type || m_path != other.m_path; } 168 169 SubTypeIterator<IsExpanded>& operator++ (void); 170 SubTypeIterator<IsExpanded> operator++ (int) { SubTypeIterator<IsExpanded> copy(*this); ++(*this); return copy; } 171 172 void toStream (std::ostream& str) const { str << TypeAccessFormat(*m_type, m_path); } 173 VarType getType (void) const { return getVarType(*m_type, m_path.begin(), m_path.end()); } 174 const TypeComponentVector& getPath (void) const { return m_path; } 175 176 VarType operator* (void) const { return getType(); } 177 178 private: 179 SubTypeIterator (const VarType* type); 180 181 void removeTraversed (void); 182 void findNext (void); 183 184 const VarType* m_type; 185 TypeComponentVector m_path; 186 }; 187 188 struct IsBasicType { bool operator() (const VarType& type) const { return type.isBasicType(); } }; 189 struct IsScalarType { bool operator() (const VarType& type) const { return type.isBasicType() && isDataTypeScalar(type.getBasicType()); } }; 190 struct IsVectorOrScalarType { bool operator() (const VarType& type) const { return type.isBasicType() && isDataTypeScalarOrVector(type.getBasicType()); } }; 191 192 typedef SubTypeIterator<IsBasicType> BasicTypeIterator; 193 typedef SubTypeIterator<IsVectorOrScalarType> VectorTypeIterator; 194 typedef SubTypeIterator<IsScalarType> ScalarTypeIterator; 195 196 template <class IsExpanded> 197 std::ostream& operator<< (std::ostream& str, const SubTypeIterator<IsExpanded>& iter) 198 { 199 iter.toStream(str); 200 return str; 201 } 202 203 template <class IsExpanded> 204 SubTypeIterator<IsExpanded>::SubTypeIterator (const VarType* type) 205 : m_type(type) 206 { 207 if (m_type) 208 findNext(); 209 } 210 211 template <class IsExpanded> 212 SubTypeIterator<IsExpanded>& SubTypeIterator<IsExpanded>::operator++ (void) 213 { 214 if (!m_path.empty()) 215 { 216 // Remove traversed nodes. 217 removeTraversed(); 218 219 if (!m_path.empty()) 220 findNext(); 221 else 222 m_type = DE_NULL; // Unset type to signal end. 223 } 224 else 225 { 226 // First type was already expanded. 227 DE_ASSERT(IsExpanded()(getVarType(*m_type, m_path))); 228 m_type = DE_NULL; 229 } 230 231 return *this; 232 } 233 234 template <class IsExpanded> 235 void SubTypeIterator<IsExpanded>::removeTraversed (void) 236 { 237 DE_ASSERT(m_type && !m_path.empty()); 238 239 // Pop traversed nodes. 240 while (!m_path.empty()) 241 { 242 VarTypeComponent& curComp = m_path.back(); 243 VarType parentType = getVarType(*m_type, m_path.begin(), m_path.end()-1); 244 245 if (curComp.type == VarTypeComponent::MATRIX_COLUMN) 246 { 247 DE_ASSERT(isDataTypeMatrix(parentType.getBasicType())); 248 if (curComp.index+1 < getDataTypeMatrixNumColumns(parentType.getBasicType())) 249 break; 250 } 251 else if (curComp.type == VarTypeComponent::VECTOR_COMPONENT) 252 { 253 DE_ASSERT(isDataTypeVector(parentType.getBasicType())); 254 if (curComp.index+1 < getDataTypeScalarSize(parentType.getBasicType())) 255 break; 256 } 257 else if (curComp.type == VarTypeComponent::ARRAY_ELEMENT) 258 { 259 DE_ASSERT(parentType.isArrayType()); 260 if (curComp.index+1 < parentType.getArraySize()) 261 break; 262 } 263 else if (curComp.type == VarTypeComponent::STRUCT_MEMBER) 264 { 265 DE_ASSERT(parentType.isStructType()); 266 if (curComp.index+1 < parentType.getStructPtr()->getNumMembers()) 267 break; 268 } 269 270 m_path.pop_back(); 271 } 272 } 273 274 template <class IsExpanded> 275 void SubTypeIterator<IsExpanded>::findNext (void) 276 { 277 if (!m_path.empty()) 278 { 279 // Increment child counter in current level. 280 VarTypeComponent& curComp = m_path.back(); 281 curComp.index += 1; 282 } 283 284 for (;;) 285 { 286 VarType curType = getVarType(*m_type, m_path); 287 288 if (IsExpanded()(curType)) 289 break; 290 291 // Recurse into child type. 292 if (curType.isBasicType()) 293 { 294 DataType basicType = curType.getBasicType(); 295 296 if (isDataTypeMatrix(basicType)) 297 m_path.push_back(VarTypeComponent(VarTypeComponent::MATRIX_COLUMN, 0)); 298 else if (isDataTypeVector(basicType)) 299 m_path.push_back(VarTypeComponent(VarTypeComponent::VECTOR_COMPONENT, 0)); 300 else 301 DE_ASSERT(false); // Can't expand scalars - IsExpanded() is buggy. 302 } 303 else if (curType.isArrayType()) 304 m_path.push_back(VarTypeComponent(VarTypeComponent::ARRAY_ELEMENT, 0)); 305 else if (curType.isStructType()) 306 m_path.push_back(VarTypeComponent(VarTypeComponent::STRUCT_MEMBER, 0)); 307 else 308 DE_ASSERT(false); 309 } 310 } 311 312 template <typename Iterator> 313 bool isValidTypePath (const VarType& type, Iterator begin, Iterator end) 314 { 315 const VarType* curType = &type; 316 Iterator pathIter = begin; 317 318 // Process struct member and array element parts of path. 319 while (pathIter != end) 320 { 321 if (pathIter->type == VarTypeComponent::STRUCT_MEMBER) 322 { 323 if (!curType->isStructType() || !de::inBounds(pathIter->index, 0, curType->getStructPtr()->getNumMembers())) 324 return false; 325 326 curType = &curType->getStructPtr()->getMember(pathIter->index).getType(); 327 } 328 else if (pathIter->type == VarTypeComponent::ARRAY_ELEMENT) 329 { 330 if (!curType->isArrayType() || (curType->getArraySize() != VarType::UNSIZED_ARRAY && !de::inBounds(pathIter->index, 0, curType->getArraySize()))) 331 return false; 332 333 curType = &curType->getElementType(); 334 } 335 else 336 break; 337 338 ++pathIter; 339 } 340 341 if (pathIter != end) 342 { 343 DE_ASSERT(pathIter->type == VarTypeComponent::MATRIX_COLUMN || pathIter->type == VarTypeComponent::VECTOR_COMPONENT); 344 345 // Current type should be basic type. 346 if (!curType->isBasicType()) 347 return false; 348 349 DataType basicType = curType->getBasicType(); 350 351 if (pathIter->type == VarTypeComponent::MATRIX_COLUMN) 352 { 353 if (!isDataTypeMatrix(basicType)) 354 return false; 355 356 basicType = getDataTypeFloatVec(getDataTypeMatrixNumRows(basicType)); 357 ++pathIter; 358 } 359 360 if (pathIter != end && pathIter->type == VarTypeComponent::VECTOR_COMPONENT) 361 { 362 if (!isDataTypeVector(basicType)) 363 return false; 364 365 basicType = getDataTypeScalarType(basicType); 366 ++pathIter; 367 } 368 } 369 370 return pathIter == end; 371 } 372 373 template <typename Iterator> 374 VarType getVarType (const VarType& type, Iterator begin, Iterator end) 375 { 376 TCU_CHECK(isValidTypePath(type, begin, end)); 377 378 const VarType* curType = &type; 379 Iterator pathIter = begin; 380 381 // Process struct member and array element parts of path. 382 while (pathIter != end) 383 { 384 if (pathIter->type == VarTypeComponent::STRUCT_MEMBER) 385 curType = &curType->getStructPtr()->getMember(pathIter->index).getType(); 386 else if (pathIter->type == VarTypeComponent::ARRAY_ELEMENT) 387 curType = &curType->getElementType(); 388 else 389 break; 390 391 ++pathIter; 392 } 393 394 if (pathIter != end) 395 { 396 DataType basicType = curType->getBasicType(); 397 Precision precision = curType->getPrecision(); 398 399 if (pathIter->type == VarTypeComponent::MATRIX_COLUMN) 400 { 401 basicType = getDataTypeFloatVec(getDataTypeMatrixNumRows(basicType)); 402 ++pathIter; 403 } 404 405 if (pathIter != end && pathIter->type == VarTypeComponent::VECTOR_COMPONENT) 406 { 407 basicType = getDataTypeScalarType(basicType); 408 ++pathIter; 409 } 410 411 DE_ASSERT(pathIter == end); 412 return VarType(basicType, precision); 413 } 414 else 415 return VarType(*curType); 416 } 417 418 } // glu 419 420 #endif // _GLUVARTYPEUTIL_HPP 421
