| // |
| // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| |
| #ifndef _BASICTYPES_INCLUDED_ |
| #define _BASICTYPES_INCLUDED_ |
| |
| #include "debug.h" |
| |
| // |
| // Precision qualifiers |
| // |
| enum TPrecision : unsigned char |
| { |
| // These need to be kept sorted |
| EbpUndefined, |
| EbpLow, |
| EbpMedium, |
| EbpHigh |
| }; |
| |
| inline const char *getPrecisionString(TPrecision precision) |
| { |
| switch(precision) |
| { |
| case EbpHigh: return "highp"; break; |
| case EbpMedium: return "mediump"; break; |
| case EbpLow: return "lowp"; break; |
| default: return "mediump"; break; // Safest fallback |
| } |
| } |
| |
| // |
| // Basic type. Arrays, vectors, etc., are orthogonal to this. |
| // |
| enum TBasicType : unsigned char |
| { |
| EbtVoid, |
| EbtFloat, |
| EbtInt, |
| EbtUInt, |
| EbtBool, |
| EbtGVec4, // non type: represents vec4, ivec4, and uvec4 |
| EbtGenType, // non type: represents float, vec2, vec3, and vec4 |
| EbtGenIType, // non type: represents int, ivec2, ivec3, and ivec4 |
| EbtGenUType, // non type: represents uint, uvec2, uvec3, and uvec4 |
| EbtGenBType, // non type: represents bool, bvec2, bvec3, and bvec4 |
| EbtVec, // non type: represents vec2, vec3, and vec4 |
| EbtIVec, // non type: represents ivec2, ivec3, and ivec4 |
| EbtUVec, // non type: represents uvec2, uvec3, and uvec4 |
| EbtBVec, // non type: represents bvec2, bvec3, and bvec4 |
| EbtGuardSamplerBegin, // non type: see implementation of IsSampler() |
| EbtSampler2D, |
| EbtSampler3D, |
| EbtSamplerCube, |
| EbtSampler2DArray, |
| EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists. |
| EbtISampler2D, |
| EbtISampler3D, |
| EbtISamplerCube, |
| EbtISampler2DArray, |
| EbtUSampler2D, |
| EbtUSampler3D, |
| EbtUSamplerCube, |
| EbtUSampler2DArray, |
| EbtSampler2DShadow, |
| EbtSamplerCubeShadow, |
| EbtSampler2DArrayShadow, |
| EbtGuardSamplerEnd, // non type: see implementation of IsSampler() |
| EbtGSampler2D, // non type: represents sampler2D, isampler2D, and usampler2D |
| EbtGSampler3D, // non type: represents sampler3D, isampler3D, and usampler3D |
| EbtGSamplerCube, // non type: represents samplerCube, isamplerCube, and usamplerCube |
| EbtGSampler2DArray, // non type: represents sampler2DArray, isampler2DArray, and usampler2DArray |
| EbtStruct, |
| EbtAddress, // should be deprecated?? |
| EbtInvariant // used as a type when qualifying a previously declared variable as being invariant |
| }; |
| |
| inline const char *getBasicString(TBasicType type) |
| { |
| switch(type) |
| { |
| case EbtVoid: return "void"; |
| case EbtFloat: return "float"; |
| case EbtInt: return "int"; |
| case EbtUInt: return "uint"; |
| case EbtBool: return "bool"; |
| case EbtSampler2D: return "sampler2D"; |
| case EbtSamplerCube: return "samplerCube"; |
| case EbtSamplerExternalOES: return "samplerExternalOES"; |
| case EbtSampler3D: return "sampler3D"; |
| case EbtStruct: return "structure"; |
| default: UNREACHABLE(); return "unknown type"; |
| } |
| } |
| |
| inline bool IsSampler(TBasicType type) |
| { |
| return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd; |
| } |
| |
| // |
| // Qualifiers and built-ins. These are mainly used to see what can be read |
| // or written, and by the machine dependent translator to know which registers |
| // to allocate variables in. Since built-ins tend to go to different registers |
| // than varying or uniform, it makes sense they are peers, not sub-classes. |
| // |
| enum TQualifier : unsigned char |
| { |
| EvqTemporary, // For temporaries (within a function), read/write |
| EvqGlobal, // For globals read/write |
| EvqConstExpr, // User defined constants |
| EvqAttribute, // Readonly |
| EvqVaryingIn, // readonly, fragment shaders only |
| EvqVaryingOut, // vertex shaders only read/write |
| EvqInvariantVaryingIn, // readonly, fragment shaders only |
| EvqInvariantVaryingOut, // vertex shaders only read/write |
| EvqUniform, // Readonly, vertex and fragment |
| |
| // pack/unpack input and output |
| EvqInput, |
| EvqOutput, |
| |
| // parameters |
| EvqIn, |
| EvqOut, |
| EvqInOut, |
| EvqConstReadOnly, |
| |
| // built-ins written by vertex shader |
| EvqPosition, |
| EvqPointSize, |
| |
| // built-ins read by fragment shader |
| EvqFragCoord, |
| EvqFrontFacing, |
| EvqPointCoord, |
| |
| // built-ins written by fragment shader |
| EvqFragColor, |
| EvqFragData, |
| |
| // GLSL ES 3.0 vertex output and fragment input |
| EvqSmooth, // Incomplete qualifier, smooth is the default |
| EvqFlat, // Incomplete qualifier |
| EvqSmoothOut = EvqSmooth, |
| EvqFlatOut = EvqFlat, |
| EvqCentroidOut, // Implies smooth |
| EvqSmoothIn, |
| EvqFlatIn, |
| EvqCentroidIn, // Implies smooth |
| |
| // end of list |
| EvqLast |
| }; |
| |
| struct TLayoutQualifier |
| { |
| static TLayoutQualifier create() |
| { |
| TLayoutQualifier layoutQualifier; |
| |
| layoutQualifier.location = -1; |
| |
| return layoutQualifier; |
| } |
| |
| bool isEmpty() const |
| { |
| return location == -1; |
| } |
| |
| int location; |
| }; |
| |
| // |
| // This is just for debug print out, carried along with the definitions above. |
| // |
| inline const char *getQualifierString(TQualifier qualifier) |
| { |
| switch(qualifier) |
| { |
| case EvqTemporary: return "Temporary"; break; |
| case EvqGlobal: return "Global"; break; |
| case EvqConstExpr: return "const"; break; |
| case EvqConstReadOnly: return "const"; break; |
| case EvqAttribute: return "attribute"; break; |
| case EvqVaryingIn: return "varying"; break; |
| case EvqVaryingOut: return "varying"; break; |
| case EvqInvariantVaryingIn: return "invariant varying"; break; |
| case EvqInvariantVaryingOut:return "invariant varying"; break; |
| case EvqUniform: return "uniform"; break; |
| case EvqIn: return "in"; break; |
| case EvqOut: return "out"; break; |
| case EvqInOut: return "inout"; break; |
| case EvqInput: return "input"; break; |
| case EvqOutput: return "output"; break; |
| case EvqPosition: return "Position"; break; |
| case EvqPointSize: return "PointSize"; break; |
| case EvqFragCoord: return "FragCoord"; break; |
| case EvqFrontFacing: return "FrontFacing"; break; |
| case EvqFragColor: return "FragColor"; break; |
| case EvqFragData: return "FragData"; break; |
| case EvqSmooth: return "Smooth"; break; |
| case EvqFlat: return "Flat"; break; |
| case EvqCentroidOut: return "CentroidOut"; break; |
| case EvqSmoothIn: return "SmoothIn"; break; |
| case EvqFlatIn: return "FlatIn"; break; |
| case EvqCentroidIn: return "CentroidIn"; break; |
| default: UNREACHABLE(); return "unknown qualifier"; |
| } |
| } |
| |
| #endif // _BASICTYPES_INCLUDED_ |
