framework/opengl/gluVarType.hpp

   1 #ifndef _GLUVARTYPE_HPP
   2 #define _GLUVARTYPE_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.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "gluShaderUtil.hpp"
  28
  29 #include <vector>
  30 #include <string>
  31 #include <ostream>
  32
  33 namespace glu
  34 {
  35
  36 class StructType;
  37
  38 /*--------------------------------------------------------------------*//*!
  39  * \brief Shader variable type.
  40  *
  41  * Variable type represents data type. No storage qualifiers are supported
  42  * since they are associated to a declaration, not to the variable type.
  43  *
  44  * \note Structs are handled using struct pointers since it is often desirable
  45  *               to maintain unique list of struct declarations.
  46  *//*--------------------------------------------------------------------*/
  47 class VarType
  48 {
  49 public:
  50                                                 VarType                 (void);
  51                                                 VarType                 (const VarType& other);
  52
  53                                                 VarType                 (DataType basicType, Precision precision);              //!< Basic type constructor.
  54                                                 VarType                 (const VarType& elementType, int arraySize);    //!< Array type constructor.
  55         explicit                        VarType                 (const StructType* structPtr);                                  //!< Struct type constructor.
  56                                                 ~VarType                (void);
  57
  58         bool                            isBasicType             (void) const    { return m_type == TYPE_BASIC;  }
  59         bool                            isArrayType             (void) const    { return m_type == TYPE_ARRAY;  }
  60         bool                            isStructType    (void) const    { return m_type == TYPE_STRUCT; }
  61
  62         DataType                        getBasicType    (void) const    { DE_ASSERT(isBasicType()); return m_data.basic.type;                   }
  63         Precision                       getPrecision    (void) const    { DE_ASSERT(isBasicType()); return m_data.basic.precision;              }
  64
  65         const VarType&          getElementType  (void) const    { DE_ASSERT(isArrayType()); return *m_data.array.elementType;   }
  66         int                                     getArraySize    (void) const    { DE_ASSERT(isArrayType()); return m_data.array.size;                   }
  67
  68         const StructType*       getStructPtr    (void) const    { DE_ASSERT(isStructType()); return m_data.structPtr;                   }
  69
  70         int                                     getScalarSize   (void) const;
  71
  72         VarType&                        operator=               (const VarType& other);
  73
  74         bool                            operator==              (const VarType& other) const;
  75         bool                            operator!=              (const VarType& other) const;
  76
  77         enum
  78         {
  79                 UNSIZED_ARRAY = -1 //!< Array length for unsized arrays.
  80         };
  81
  82 private:
  83         enum Type
  84         {
  85                 TYPE_BASIC,
  86                 TYPE_ARRAY,
  87                 TYPE_STRUCT,
  88
  89                 TYPE_LAST
  90         };
  91
  92         Type                            m_type;
  93         union Data
  94         {
  95                 // TYPE_BASIC
  96                 struct
  97                 {
  98                         DataType                type;
  99                         Precision               precision;
 100                 } basic;
 101
 102                 // TYPE_ARRAY
 103                 struct
 104                 {
 105                         VarType*                elementType;
 106                         int                             size;
 107                 } array;
 108
 109                 // TYPE_STRUCT
 110                 const StructType*       structPtr;
 111
 112                 Data (void)
 113                 {
 114                         array.elementType       = DE_NULL;
 115                         array.size                      = 0;
 116                 };
 117         } m_data;
 118 };
 119
 120 template <typename T>
 121 inline VarType varTypeOf (Precision prec = PRECISION_LAST) { return VarType(dataTypeOf<T>(), prec); }
 122
 123 class StructMember
 124 {
 125 public:
 126                                                 StructMember    (const char* name, const VarType& type) : m_name(name), m_type(type) {}
 127                                                 StructMember    (void) {}
 128
 129         const char*                     getName                 (void) const { return m_name.c_str();   }
 130         const VarType&          getType                 (void) const { return m_type;                   }
 131
 132         bool                            operator==              (const StructMember& other) const;
 133         bool                            operator!=              (const StructMember& other) const;
 134
 135 private:
 136         std::string                     m_name;
 137         VarType                         m_type;
 138 };
 139
 140 class StructType
 141 {
 142 public:
 143         typedef std::vector<StructMember>::iterator                     Iterator;
 144         typedef std::vector<StructMember>::const_iterator       ConstIterator;
 145
 146                                                                 StructType              (const char* typeName) : m_typeName(typeName) {}
 147                                                                 ~StructType             (void) {}
 148
 149         bool                                            hasTypeName             (void) const    { return !m_typeName.empty();   }
 150         const char*                                     getTypeName             (void) const    { return hasTypeName() ? m_typeName.c_str() : DE_NULL; }
 151
 152         void                                            addMember               (const char* name, const VarType& type);
 153
 154         int                                                     getNumMembers   (void) const    { return (int)m_members.size(); }
 155         const StructMember&                     getMember               (int ndx) const { return m_members[ndx];                }
 156
 157         inline Iterator                         begin                   (void)                  { return m_members.begin();             }
 158         inline ConstIterator            begin                   (void) const    { return m_members.begin();             }
 159         inline Iterator                         end                             (void)                  { return m_members.end();               }
 160         inline ConstIterator            end                             (void) const    { return m_members.end();               }
 161
 162         bool                                            operator==              (const StructType& other) const;
 163         bool                                            operator!=              (const StructType& other) const;
 164
 165 private:
 166         std::string                                     m_typeName;
 167         std::vector<StructMember>       m_members;
 168 };
 169
 170 enum Storage
 171 {
 172         STORAGE_IN = 0,
 173         STORAGE_OUT,
 174         STORAGE_CONST,
 175         STORAGE_UNIFORM,
 176         STORAGE_BUFFER,
 177         STORAGE_LAST
 178 };
 179
 180 const char* getStorageName (Storage storage);
 181
 182 enum Interpolation
 183 {
 184         INTERPOLATION_SMOOTH = 0,
 185         INTERPOLATION_FLAT,
 186         INTERPOLATION_CENTROID,
 187         INTERPOLATION_LAST
 188 };
 189
 190 const char* getInterpolationName (Interpolation interpolation);
 191
 192 enum FormatLayout
 193 {
 194         FORMATLAYOUT_RGBA32F = 0,
 195         FORMATLAYOUT_RGBA16F,
 196         FORMATLAYOUT_R32F,
 197         FORMATLAYOUT_RGBA8,
 198         FORMATLAYOUT_RGBA8_SNORM,
 199
 200         FORMATLAYOUT_RGBA32I,
 201         FORMATLAYOUT_RGBA16I,
 202         FORMATLAYOUT_RGBA8I,
 203         FORMATLAYOUT_R32I,
 204
 205         FORMATLAYOUT_RGBA32UI,
 206         FORMATLAYOUT_RGBA16UI,
 207         FORMATLAYOUT_RGBA8UI,
 208         FORMATLAYOUT_R32UI,
 209
 210         FORMATLAYOUT_LAST
 211 };
 212
 213 const char* getFormatLayoutName (FormatLayout layout);
 214
 215 enum MemoryAccessQualifier
 216 {
 217         MEMORYACCESSQUALIFIER_COHERENT_BIT      = 0x01,
 218         MEMORYACCESSQUALIFIER_VOLATILE_BIT      = 0x02,
 219         MEMORYACCESSQUALIFIER_RESTRICT_BIT      = 0x04,
 220         MEMORYACCESSQUALIFIER_READONLY_BIT      = 0x08,
 221         MEMORYACCESSQUALIFIER_WRITEONLY_BIT     = 0x10,
 222
 223         MEMORYACCESSQUALIFIER_MASK = (MEMORYACCESSQUALIFIER_WRITEONLY_BIT << 1) - 1
 224 };
 225
 226 const char* getMemoryAccessQualifierName (MemoryAccessQualifier qualifier);
 227
 228 enum MatrixOrder
 229 {
 230         MATRIXORDER_COLUMN_MAJOR = 0,
 231         MATRIXORDER_ROW_MAJOR,
 232
 233         MATRIXORDER_LAST
 234 };
 235
 236 const char* getMatrixOrderName (MatrixOrder qualifier);
 237
 238 // Declaration utilities.
 239
 240 struct Layout
 241 {
 242                                         Layout                  (int location_ = -1, int binding_ = -1, int offset_ = -1, FormatLayout format_ = FORMATLAYOUT_LAST, MatrixOrder matrixOrder_ = MATRIXORDER_LAST);
 243
 244         bool                    operator==              (const Layout& other) const;
 245         bool                    operator!=              (const Layout& other) const;
 246
 247         int                             location;
 248         int                             binding;
 249         int                             offset;
 250         FormatLayout    format;
 251         MatrixOrder             matrixOrder;
 252 };
 253
 254 struct VariableDeclaration
 255 {
 256                                                 VariableDeclaration     (const VarType& varType_, const std::string& name_, Storage storage_ = STORAGE_LAST, Interpolation interpolation_ = INTERPOLATION_LAST, const Layout& layout_ = Layout(), deUint32 memoryAccessQualifierBits_ = 0);
 257
 258         bool                            operator==                      (const VariableDeclaration& other) const;
 259         bool                            operator!=                      (const VariableDeclaration& other) const;
 260
 261         Layout                          layout;
 262         Interpolation           interpolation;
 263         Storage                         storage;
 264         VarType                         varType;
 265         deUint32                        memoryAccessQualifierBits;
 266         std::string                     name;
 267 };
 268
 269 struct InterfaceBlock
 270 {
 271                                                                                         InterfaceBlock  (void);
 272
 273         glu::Layout                                                             layout;
 274         Storage                                                                 storage;
 275         int                                                                             memoryAccessQualifierFlags;
 276         std::string                                                             interfaceName;
 277         std::string                                                             instanceName;
 278         std::vector<glu::VariableDeclaration>   variables;
 279         std::vector<int>                                                dimensions;
 280 };
 281
 282 //! Internals for declare() utilities.
 283 namespace decl
 284 {
 285
 286 struct Indent
 287 {
 288         int level;
 289         Indent (int level_) : level(level_) {}
 290 };
 291
 292 struct DeclareStructTypePtr
 293 {
 294         DeclareStructTypePtr (const StructType* structPtr_, int indentLevel_) : structPtr(structPtr_), indentLevel(indentLevel_) {}
 295
 296         const StructType*       structPtr;
 297         int                                     indentLevel;
 298 };
 299
 300 struct DeclareStructType
 301 {
 302         DeclareStructType (const StructType& structType_, int indentLevel_) : structType(structType_), indentLevel(indentLevel_) {}
 303
 304         StructType                      structType;
 305         int                                     indentLevel;
 306 };
 307
 308 struct DeclareVariable
 309 {
 310         DeclareVariable (const VarType& varType_, const std::string& name_, int indentLevel_) : varType(varType_), name(name_), indentLevel(indentLevel_) {}
 311
 312         VarType                         varType;
 313         std::string                     name;
 314         int                                     indentLevel;
 315 };
 316
 317 std::ostream&           operator<<              (std::ostream& str, const Indent&                               indent);
 318 std::ostream&           operator<<              (std::ostream& str, const DeclareStructTypePtr& decl);
 319 std::ostream&           operator<<              (std::ostream& str, const DeclareStructType&    decl);
 320 std::ostream&           operator<<              (std::ostream& str, const DeclareVariable&              decl);
 321
 322 } // decl
 323
 324 inline decl::Indent                                     indent                  (int indentLevel)                                                                                                               { return decl::Indent(indentLevel);                                                                     }
 325 inline decl::DeclareStructTypePtr       declare                 (const StructType*      structPtr,      int indentLevel = 0)                                    { return decl::DeclareStructTypePtr     (structPtr,             indentLevel);   }
 326 inline decl::DeclareStructType          declare                 (const StructType&      structType,     int indentLevel = 0)                                    { return decl::DeclareStructType        (structType,    indentLevel);   }
 327 inline decl::DeclareVariable            declare                 (const VarType& varType, const std::string& name, int indentLevel = 0)  { return decl::DeclareVariable          (varType, name, indentLevel);   }
 328
 329 std::ostream&                                           operator<<              (std::ostream& str, const Layout& decl);
 330 std::ostream&                                           operator<<              (std::ostream& str, const VariableDeclaration& decl);
 331
 332 } // glu
 333
 334 #endif // _GLUVARTYPE_HPP