src/third_party/angle/src/compiler/translator/BaseTypes.h

   1 //
   2 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 #ifndef _BASICTYPES_INCLUDED_
   8 #define _BASICTYPES_INCLUDED_
   9
  10 #include <assert.h>
  11
  12 //
  13 // Precision qualifiers
  14 //
  15 enum TPrecision
  16 {
  17     // These need to be kept sorted
  18     EbpUndefined,
  19     EbpLow,
  20     EbpMedium,
  21     EbpHigh
  22 };
  23
  24 inline const char* getPrecisionString(TPrecision p)
  25 {
  26     switch(p)
  27     {
  28     case EbpHigh:               return "highp";         break;
  29     case EbpMedium:             return "mediump";       break;
  30     case EbpLow:                return "lowp";          break;
  31     default:                    return "mediump";   break;   // Safest fallback
  32     }
  33 }
  34
  35 //
  36 // Basic type.  Arrays, vectors, etc., are orthogonal to this.
  37 //
  38 enum TBasicType
  39 {
  40     EbtVoid,
  41     EbtFloat,
  42     EbtInt,
  43     EbtUInt,
  44     EbtBool,
  45     EbtGVec4,              // non type: represents vec4, ivec4 and uvec4
  46     EbtGuardSamplerBegin,  // non type: see implementation of IsSampler()
  47     EbtSampler2D,
  48     EbtSampler3D,
  49     EbtSamplerCube,
  50     EbtSampler2DArray,
  51     EbtSamplerExternalOES,  // Only valid if OES_EGL_image_external exists.
  52     EbtSampler2DRect,       // Only valid if GL_ARB_texture_rectangle exists.
  53     EbtISampler2D,
  54     EbtISampler3D,
  55     EbtISamplerCube,
  56     EbtISampler2DArray,
  57     EbtUSampler2D,
  58     EbtUSampler3D,
  59     EbtUSamplerCube,
  60     EbtUSampler2DArray,
  61     EbtSampler2DShadow,
  62     EbtSamplerCubeShadow,
  63     EbtSampler2DArrayShadow,
  64     EbtGuardSamplerEnd,    // non type: see implementation of IsSampler()
  65     EbtGSampler2D,         // non type: represents sampler2D, isampler2D and usampler2D
  66     EbtGSampler3D,         // non type: represents sampler3D, isampler3D and usampler3D
  67     EbtGSamplerCube,       // non type: represents samplerCube, isamplerCube and usamplerCube
  68     EbtGSampler2DArray,    // non type: represents sampler2DArray, isampler2DArray and usampler2DArray
  69     EbtStruct,
  70     EbtInterfaceBlock,
  71     EbtAddress,            // should be deprecated??
  72     EbtInvariant          // used as a type when qualifying a previously declared variable as being invariant
  73 };
  74
  75 const char* getBasicString(TBasicType t);
  76
  77 inline bool IsSampler(TBasicType type)
  78 {
  79     return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
  80 }
  81
  82 inline bool IsIntegerSampler(TBasicType type)
  83 {
  84     switch (type)
  85     {
  86       case EbtISampler2D:
  87       case EbtISampler3D:
  88       case EbtISamplerCube:
  89       case EbtISampler2DArray:
  90       case EbtUSampler2D:
  91       case EbtUSampler3D:
  92       case EbtUSamplerCube:
  93       case EbtUSampler2DArray:
  94         return true;
  95       case EbtSampler2D:
  96       case EbtSampler3D:
  97       case EbtSamplerCube:
  98       case EbtSamplerExternalOES:
  99       case EbtSampler2DRect:
 100       case EbtSampler2DArray:
 101       case EbtSampler2DShadow:
 102       case EbtSamplerCubeShadow:
 103       case EbtSampler2DArrayShadow:
 104         return false;
 105       default:
 106         assert(!IsSampler(type));
 107     }
 108
 109     return false;
 110 }
 111
 112 inline bool IsSampler2D(TBasicType type)
 113 {
 114     switch (type)
 115     {
 116       case EbtSampler2D:
 117       case EbtISampler2D:
 118       case EbtUSampler2D:
 119       case EbtSampler2DArray:
 120       case EbtISampler2DArray:
 121       case EbtUSampler2DArray:
 122       case EbtSampler2DRect:
 123       case EbtSamplerExternalOES:
 124       case EbtSampler2DShadow:
 125       case EbtSampler2DArrayShadow:
 126         return true;
 127       case EbtSampler3D:
 128       case EbtISampler3D:
 129       case EbtUSampler3D:
 130       case EbtISamplerCube:
 131       case EbtUSamplerCube:
 132       case EbtSamplerCube:
 133       case EbtSamplerCubeShadow:
 134         return false;
 135       default:
 136         assert(!IsSampler(type));
 137     }
 138
 139     return false;
 140 }
 141
 142 inline bool IsSamplerCube(TBasicType type)
 143 {
 144     switch (type)
 145     {
 146       case EbtSamplerCube:
 147       case EbtISamplerCube:
 148       case EbtUSamplerCube:
 149       case EbtSamplerCubeShadow:
 150         return true;
 151       case EbtSampler2D:
 152       case EbtSampler3D:
 153       case EbtSamplerExternalOES:
 154       case EbtSampler2DRect:
 155       case EbtSampler2DArray:
 156       case EbtISampler2D:
 157       case EbtISampler3D:
 158       case EbtISampler2DArray:
 159       case EbtUSampler2D:
 160       case EbtUSampler3D:
 161       case EbtUSampler2DArray:
 162       case EbtSampler2DShadow:
 163       case EbtSampler2DArrayShadow:
 164         return false;
 165       default:
 166         assert(!IsSampler(type));
 167     }
 168
 169     return false;
 170 }
 171
 172 inline bool IsSampler3D(TBasicType type)
 173 {
 174     switch (type)
 175     {
 176       case EbtSampler3D:
 177       case EbtISampler3D:
 178       case EbtUSampler3D:
 179         return true;
 180       case EbtSampler2D:
 181       case EbtSamplerCube:
 182       case EbtSamplerExternalOES:
 183       case EbtSampler2DRect:
 184       case EbtSampler2DArray:
 185       case EbtISampler2D:
 186       case EbtISamplerCube:
 187       case EbtISampler2DArray:
 188       case EbtUSampler2D:
 189       case EbtUSamplerCube:
 190       case EbtUSampler2DArray:
 191       case EbtSampler2DShadow:
 192       case EbtSamplerCubeShadow:
 193       case EbtSampler2DArrayShadow:
 194         return false;
 195       default:
 196         assert(!IsSampler(type));
 197     }
 198
 199     return false;
 200 }
 201
 202 inline bool IsSamplerArray(TBasicType type)
 203 {
 204     switch (type)
 205     {
 206       case EbtSampler2DArray:
 207       case EbtISampler2DArray:
 208       case EbtUSampler2DArray:
 209       case EbtSampler2DArrayShadow:
 210         return true;
 211       case EbtSampler2D:
 212       case EbtISampler2D:
 213       case EbtUSampler2D:
 214       case EbtSampler2DRect:
 215       case EbtSamplerExternalOES:
 216       case EbtSampler3D:
 217       case EbtISampler3D:
 218       case EbtUSampler3D:
 219       case EbtISamplerCube:
 220       case EbtUSamplerCube:
 221       case EbtSamplerCube:
 222       case EbtSampler2DShadow:
 223       case EbtSamplerCubeShadow:
 224         return false;
 225       default:
 226         assert(!IsSampler(type));
 227     }
 228
 229     return false;
 230 }
 231
 232 inline bool IsShadowSampler(TBasicType type)
 233 {
 234     switch (type)
 235     {
 236       case EbtSampler2DShadow:
 237       case EbtSamplerCubeShadow:
 238       case EbtSampler2DArrayShadow:
 239         return true;
 240       case EbtISampler2D:
 241       case EbtISampler3D:
 242       case EbtISamplerCube:
 243       case EbtISampler2DArray:
 244       case EbtUSampler2D:
 245       case EbtUSampler3D:
 246       case EbtUSamplerCube:
 247       case EbtUSampler2DArray:
 248       case EbtSampler2D:
 249       case EbtSampler3D:
 250       case EbtSamplerCube:
 251       case EbtSamplerExternalOES:
 252       case EbtSampler2DRect:
 253       case EbtSampler2DArray:
 254         return false;
 255       default:
 256         assert(!IsSampler(type));
 257     }
 258
 259     return false;
 260 }
 261
 262 inline bool SupportsPrecision(TBasicType type)
 263 {
 264     return type == EbtFloat || type == EbtInt || type == EbtUInt || IsSampler(type);
 265 }
 266
 267 //
 268 // Qualifiers and built-ins.  These are mainly used to see what can be read
 269 // or written, and by the machine dependent translator to know which registers
 270 // to allocate variables in.  Since built-ins tend to go to different registers
 271 // than varying or uniform, it makes sense they are peers, not sub-classes.
 272 //
 273 enum TQualifier
 274 {
 275     EvqTemporary,     // For temporaries (within a function), read/write
 276     EvqGlobal,        // For globals read/write
 277     EvqInternal,      // For internal use, not visible to the user
 278     EvqConst,         // User defined constants and non-output parameters in functions
 279     EvqAttribute,     // Readonly
 280     EvqVaryingIn,     // readonly, fragment shaders only
 281     EvqVaryingOut,    // vertex shaders only  read/write
 282     EvqInvariantVaryingIn,     // readonly, fragment shaders only
 283     EvqInvariantVaryingOut,    // vertex shaders only  read/write
 284     EvqUniform,       // Readonly, vertex and fragment
 285
 286     EvqVertexIn,      // Vertex shader input
 287     EvqFragmentOut,   // Fragment shader output
 288     EvqVertexOut,     // Vertex shader output
 289     EvqFragmentIn,    // Fragment shader input
 290
 291     // parameters
 292     EvqIn,
 293     EvqOut,
 294     EvqInOut,
 295     EvqConstReadOnly,
 296
 297     // built-ins written by vertex shader
 298     EvqPosition,
 299     EvqPointSize,
 300
 301     // built-ins read by fragment shader
 302     EvqFragCoord,
 303     EvqFrontFacing,
 304     EvqPointCoord,
 305
 306     // built-ins written by fragment shader
 307     EvqFragColor,
 308     EvqFragData,
 309     EvqFragDepth,
 310
 311     // GLSL ES 3.0 vertex output and fragment input
 312     EvqSmooth,        // Incomplete qualifier, smooth is the default
 313     EvqFlat,          // Incomplete qualifier
 314     EvqSmoothOut = EvqSmooth,
 315     EvqFlatOut = EvqFlat,
 316     EvqCentroidOut,   // Implies smooth
 317     EvqSmoothIn,
 318     EvqFlatIn,
 319     EvqCentroidIn,    // Implies smooth
 320
 321     // end of list
 322     EvqLast
 323 };
 324
 325 enum TLayoutMatrixPacking
 326 {
 327     EmpUnspecified,
 328     EmpRowMajor,
 329     EmpColumnMajor
 330 };
 331
 332 enum TLayoutBlockStorage
 333 {
 334     EbsUnspecified,
 335     EbsShared,
 336     EbsPacked,
 337     EbsStd140
 338 };
 339
 340 struct TLayoutQualifier
 341 {
 342     int location;
 343     TLayoutMatrixPacking matrixPacking;
 344     TLayoutBlockStorage blockStorage;
 345
 346     static TLayoutQualifier create()
 347     {
 348         TLayoutQualifier layoutQualifier;
 349
 350         layoutQualifier.location = -1;
 351         layoutQualifier.matrixPacking = EmpUnspecified;
 352         layoutQualifier.blockStorage = EbsUnspecified;
 353
 354         return layoutQualifier;
 355     }
 356
 357     bool isEmpty() const
 358     {
 359         return location == -1 && matrixPacking == EmpUnspecified && blockStorage == EbsUnspecified;
 360     }
 361 };
 362
 363 //
 364 // This is just for debug print out, carried along with the definitions above.
 365 //
 366 inline const char* getQualifierString(TQualifier q)
 367 {
 368     switch(q)
 369     {
 370     case EvqTemporary:      return "Temporary";      break;
 371     case EvqGlobal:         return "Global";         break;
 372     case EvqConst:          return "const";          break;
 373     case EvqConstReadOnly:  return "const";          break;
 374     case EvqAttribute:      return "attribute";      break;
 375     case EvqVaryingIn:      return "varying";        break;
 376     case EvqVaryingOut:     return "varying";        break;
 377     case EvqInvariantVaryingIn: return "invariant varying";     break;
 378     case EvqInvariantVaryingOut:return "invariant varying";     break;
 379     case EvqUniform:        return "uniform";        break;
 380     case EvqVertexIn:       return "in";             break;
 381     case EvqFragmentOut:    return "out";            break;
 382     case EvqVertexOut:      return "out";            break;
 383     case EvqFragmentIn:     return "in";             break;
 384     case EvqIn:             return "in";             break;
 385     case EvqOut:            return "out";            break;
 386     case EvqInOut:          return "inout";          break;
 387     case EvqPosition:       return "Position";       break;
 388     case EvqPointSize:      return "PointSize";      break;
 389     case EvqFragCoord:      return "FragCoord";      break;
 390     case EvqFrontFacing:    return "FrontFacing";    break;
 391     case EvqFragColor:      return "FragColor";      break;
 392     case EvqFragData:       return "FragData";       break;
 393     case EvqFragDepth:      return "FragDepth";      break;
 394     case EvqSmoothOut:      return "smooth out";     break;
 395     case EvqCentroidOut:    return "centroid out";   break;
 396     case EvqFlatOut:        return "flat out";       break;
 397     case EvqSmoothIn:       return "smooth in";      break;
 398     case EvqCentroidIn:     return "centroid in";    break;
 399     case EvqFlatIn:         return "flat in";        break;
 400     default:                return "unknown qualifier";
 401     }
 402 }
 403
 404 inline const char* getMatrixPackingString(TLayoutMatrixPacking mpq)
 405 {
 406     switch (mpq)
 407     {
 408     case EmpUnspecified:    return "mp_unspecified";
 409     case EmpRowMajor:       return "row_major";
 410     case EmpColumnMajor:    return "column_major";
 411     default:                return "unknown matrix packing";
 412     }
 413 }
 414
 415 inline const char* getBlockStorageString(TLayoutBlockStorage bsq)
 416 {
 417     switch (bsq)
 418     {
 419     case EbsUnspecified:    return "bs_unspecified";
 420     case EbsShared:         return "shared";
 421     case EbsPacked:         return "packed";
 422     case EbsStd140:         return "std140";
 423     default:                return "unknown block storage";
 424     }
 425 }
 426
 427 inline const char* getInterpolationString(TQualifier q)
 428 {
 429     switch(q)
 430     {
 431     case EvqSmoothOut:      return "smooth";   break;
 432     case EvqCentroidOut:    return "centroid"; break;
 433     case EvqFlatOut:        return "flat";     break;
 434     case EvqSmoothIn:       return "smooth";   break;
 435     case EvqCentroidIn:     return "centroid"; break;
 436     case EvqFlatIn:         return "flat";     break;
 437     default:                return "unknown interpolation";
 438     }
 439 }
 440
 441 #endif // _BASICTYPES_INCLUDED_