framework/opengl/gluShaderUtil.hpp

   1 #ifndef _GLUSHADERUTIL_HPP
   2 #define _GLUSHADERUTIL_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 utilities.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "deInt32.h"
  28 #include "gluRenderContext.hpp"
  29 #include "tcuVector.hpp"
  30 #include "tcuVector.hpp"
  31 #include "tcuMatrix.hpp"
  32
  33 namespace glu
  34 {
  35
  36 // ShadingLanguageVersion
  37
  38 enum GLSLVersion
  39 {
  40         GLSL_VERSION_100_ES = 0,        //!< GLSL ES 1.0
  41         GLSL_VERSION_300_ES,            //!< GLSL ES 3.0
  42         GLSL_VERSION_310_ES,            //!< GLSL ES 3.1
  43         GLSL_VERSION_320_ES,            //!< GLSL ES 3.2
  44
  45         GLSL_VERSION_130,                       //!< GLSL 1.3
  46         GLSL_VERSION_140,                       //!< GLSL 1.4
  47         GLSL_VERSION_150,                       //!< GLSL 1.5
  48         GLSL_VERSION_330,                       //!< GLSL 3.0
  49         GLSL_VERSION_400,                       //!< GLSL 4.0
  50         GLSL_VERSION_410,                       //!< GLSL 4.1
  51         GLSL_VERSION_420,                       //!< GLSL 4.2
  52         GLSL_VERSION_430,                       //!< GLSL 4.3
  53         GLSL_VERSION_440,                       //!< GLSL 4.4
  54         GLSL_VERSION_450,                       //!< GLSL 4.5
  55
  56         GLSL_VERSION_LAST
  57 };
  58
  59 const char*             getGLSLVersionName                              (GLSLVersion version);
  60 const char*             getGLSLVersionDeclaration               (GLSLVersion version);
  61 bool                    glslVersionUsesInOutQualifiers  (GLSLVersion version);
  62 bool                    glslVersionIsES                                 (GLSLVersion version);
  63 bool                    isGLSLVersionSupported                  (ContextType type, GLSLVersion version);
  64 GLSLVersion             getContextTypeGLSLVersion               (ContextType type);
  65
  66 // ShaderType
  67
  68 enum ShaderType
  69 {
  70         SHADERTYPE_VERTEX = 0,
  71         SHADERTYPE_FRAGMENT,
  72         SHADERTYPE_GEOMETRY,
  73         SHADERTYPE_TESSELLATION_CONTROL,
  74         SHADERTYPE_TESSELLATION_EVALUATION,
  75         SHADERTYPE_COMPUTE,
  76
  77         SHADERTYPE_LAST
  78 };
  79
  80 const char*     getShaderTypeName (ShaderType shaderType);
  81
  82 // Precision
  83
  84 enum Precision
  85 {
  86         PRECISION_LOWP = 0,
  87         PRECISION_MEDIUMP,
  88         PRECISION_HIGHP,
  89
  90         PRECISION_LAST
  91 };
  92
  93 const char* getPrecisionName (Precision precision);
  94
  95 // DataType
  96
  97 enum DataType
  98 {
  99         TYPE_INVALID    = 0,
 100
 101         TYPE_FLOAT,
 102         TYPE_FLOAT_VEC2,
 103         TYPE_FLOAT_VEC3,
 104         TYPE_FLOAT_VEC4,
 105         TYPE_FLOAT_MAT2,
 106         TYPE_FLOAT_MAT2X3,
 107         TYPE_FLOAT_MAT2X4,
 108         TYPE_FLOAT_MAT3X2,
 109         TYPE_FLOAT_MAT3,
 110         TYPE_FLOAT_MAT3X4,
 111         TYPE_FLOAT_MAT4X2,
 112         TYPE_FLOAT_MAT4X3,
 113         TYPE_FLOAT_MAT4,
 114
 115         TYPE_INT,
 116         TYPE_INT_VEC2,
 117         TYPE_INT_VEC3,
 118         TYPE_INT_VEC4,
 119
 120         TYPE_UINT,
 121         TYPE_UINT_VEC2,
 122         TYPE_UINT_VEC3,
 123         TYPE_UINT_VEC4,
 124
 125         TYPE_BOOL,
 126         TYPE_BOOL_VEC2,
 127         TYPE_BOOL_VEC3,
 128         TYPE_BOOL_VEC4,
 129
 130         TYPE_SAMPLER_1D,
 131         TYPE_SAMPLER_2D,
 132         TYPE_SAMPLER_CUBE,
 133         TYPE_SAMPLER_2D_ARRAY,
 134         TYPE_SAMPLER_3D,
 135         TYPE_SAMPLER_CUBE_ARRAY,
 136
 137         TYPE_SAMPLER_1D_SHADOW,
 138         TYPE_SAMPLER_2D_SHADOW,
 139         TYPE_SAMPLER_CUBE_SHADOW,
 140         TYPE_SAMPLER_2D_ARRAY_SHADOW,
 141         TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
 142
 143         TYPE_INT_SAMPLER_1D,
 144         TYPE_INT_SAMPLER_2D,
 145         TYPE_INT_SAMPLER_CUBE,
 146         TYPE_INT_SAMPLER_2D_ARRAY,
 147         TYPE_INT_SAMPLER_3D,
 148         TYPE_INT_SAMPLER_CUBE_ARRAY,
 149
 150         TYPE_UINT_SAMPLER_1D,
 151         TYPE_UINT_SAMPLER_2D,
 152         TYPE_UINT_SAMPLER_CUBE,
 153         TYPE_UINT_SAMPLER_2D_ARRAY,
 154         TYPE_UINT_SAMPLER_3D,
 155         TYPE_UINT_SAMPLER_CUBE_ARRAY,
 156
 157         TYPE_SAMPLER_2D_MULTISAMPLE,
 158         TYPE_INT_SAMPLER_2D_MULTISAMPLE,
 159         TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
 160
 161         TYPE_IMAGE_2D,
 162         TYPE_IMAGE_CUBE,
 163         TYPE_IMAGE_2D_ARRAY,
 164         TYPE_IMAGE_3D,
 165         TYPE_IMAGE_CUBE_ARRAY,
 166
 167         TYPE_INT_IMAGE_2D,
 168         TYPE_INT_IMAGE_CUBE,
 169         TYPE_INT_IMAGE_2D_ARRAY,
 170         TYPE_INT_IMAGE_3D,
 171         TYPE_INT_IMAGE_CUBE_ARRAY,
 172
 173         TYPE_UINT_IMAGE_2D,
 174         TYPE_UINT_IMAGE_CUBE,
 175         TYPE_UINT_IMAGE_2D_ARRAY,
 176         TYPE_UINT_IMAGE_3D,
 177         TYPE_UINT_IMAGE_CUBE_ARRAY,
 178
 179         TYPE_UINT_ATOMIC_COUNTER,
 180
 181         TYPE_SAMPLER_BUFFER,
 182         TYPE_INT_SAMPLER_BUFFER,
 183         TYPE_UINT_SAMPLER_BUFFER,
 184
 185         TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
 186         TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
 187         TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
 188
 189         TYPE_IMAGE_BUFFER,
 190         TYPE_INT_IMAGE_BUFFER,
 191         TYPE_UINT_IMAGE_BUFFER,
 192
 193         TYPE_LAST
 194 };
 195
 196 const char*             getDataTypeName                         (DataType dataType);
 197 int                             getDataTypeScalarSize           (DataType dataType);
 198 DataType                getDataTypeScalarType           (DataType dataType);
 199 DataType                getDataTypeFloatScalars         (DataType dataType);
 200 DataType                getDataTypeVector                       (DataType scalarType, int size);
 201 DataType                getDataTypeFloatVec                     (int vecSize);
 202 DataType                getDataTypeIntVec                       (int vecSize);
 203 DataType                getDataTypeUintVec                      (int vecSize);
 204 DataType                getDataTypeBoolVec                      (int vecSize);
 205 DataType                getDataTypeMatrix                       (int numCols, int numRows);
 206 DataType                getDataTypeFromGLType           (deUint32 glType);
 207
 208 inline bool             isDataTypeFloatOrVec            (DataType dataType)     { return (dataType >= TYPE_FLOAT)      && (dataType <= TYPE_FLOAT_VEC4);   }
 209 inline bool             isDataTypeMatrix                        (DataType dataType)     { return (dataType >= TYPE_FLOAT_MAT2) && (dataType <= TYPE_FLOAT_MAT4);   }
 210 inline bool             isDataTypeIntOrIVec                     (DataType dataType)     { return (dataType >= TYPE_INT)        && (dataType <= TYPE_INT_VEC4);     }
 211 inline bool             isDataTypeUintOrUVec            (DataType dataType)     { return (dataType >= TYPE_UINT)       && (dataType <= TYPE_UINT_VEC4);     }
 212 inline bool             isDataTypeBoolOrBVec            (DataType dataType)     { return (dataType >= TYPE_BOOL)       && (dataType <= TYPE_BOOL_VEC4);    }
 213 inline bool             isDataTypeScalar                        (DataType dataType) { return (dataType == TYPE_FLOAT) || (dataType == TYPE_INT) || (dataType == TYPE_UINT) || (dataType == TYPE_BOOL); }
 214 inline bool             isDataTypeVector                        (DataType dataType) { return deInRange32(dataType, TYPE_FLOAT_VEC2, TYPE_FLOAT_VEC4) || deInRange32(dataType, TYPE_INT_VEC2, TYPE_INT_VEC4) || deInRange32(dataType, TYPE_UINT_VEC2, TYPE_UINT_VEC4) || deInRange32(dataType, TYPE_BOOL_VEC2, TYPE_BOOL_VEC4); }
 215 inline bool             isDataTypeScalarOrVector        (DataType dataType) { return deInRange32(dataType, TYPE_FLOAT, TYPE_FLOAT_VEC4) || deInRange32(dataType, TYPE_INT, TYPE_INT_VEC4) || deInRange32(dataType, TYPE_UINT, TYPE_UINT_VEC4) || deInRange32(dataType, TYPE_BOOL, TYPE_BOOL_VEC4); }
 216 inline bool             isDataTypeSampler                       (DataType dataType)     { return (dataType >= TYPE_SAMPLER_1D) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE); }
 217 inline bool             isDataTypeImage                         (DataType dataType)     { return (dataType >= TYPE_IMAGE_2D) && (dataType <= TYPE_UINT_IMAGE_3D); }
 218 inline bool             isDataTypeSamplerMultisample(DataType dataType) { return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE); }
 219 inline bool             isDataTypeAtomicCounter         (DataType dataType)     { return dataType == TYPE_UINT_ATOMIC_COUNTER; }
 220 inline bool             isDataTypeSamplerBuffer         (DataType dataType)     { return (dataType >= TYPE_SAMPLER_BUFFER) && (dataType <= TYPE_UINT_SAMPLER_BUFFER); }
 221 inline bool             isDataTypeSamplerMSArray        (DataType dataType)     { return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY); }
 222 inline bool             isDataTypeImageBuffer           (DataType dataType)     { return (dataType >= TYPE_IMAGE_BUFFER) && (dataType <= TYPE_UINT_IMAGE_BUFFER); }
 223
 224 int                             getDataTypeMatrixNumRows        (DataType dataType);
 225 int                             getDataTypeMatrixNumColumns     (DataType dataType);
 226
 227 int                             getDataTypeNumLocations         (DataType dataType);
 228 int                             getDataTypeNumComponents        (DataType dataType);
 229
 230 template <typename T>
 231 struct DataTypeTraits;
 232
 233 template <> struct DataTypeTraits<float>                { enum { DATATYPE = TYPE_FLOAT                  }; };
 234 template <> struct DataTypeTraits<bool>                 { enum { DATATYPE = TYPE_BOOL                   }; };
 235 template <> struct DataTypeTraits<int>                  { enum { DATATYPE = TYPE_INT                    }; };
 236 template <> struct DataTypeTraits<deUint32>             { enum { DATATYPE = TYPE_UINT                   }; };
 237 template <> struct DataTypeTraits<tcu::Mat2>    { enum { DATATYPE = TYPE_FLOAT_MAT2             }; };
 238 template <> struct DataTypeTraits<tcu::Mat2x3>  { enum { DATATYPE = TYPE_FLOAT_MAT2X3   }; };
 239 template <> struct DataTypeTraits<tcu::Mat2x4>  { enum { DATATYPE = TYPE_FLOAT_MAT2X4   }; };
 240 template <> struct DataTypeTraits<tcu::Mat3x2>  { enum { DATATYPE = TYPE_FLOAT_MAT3X2   }; };
 241 template <> struct DataTypeTraits<tcu::Mat3>    { enum { DATATYPE = TYPE_FLOAT_MAT3             }; };
 242 template <> struct DataTypeTraits<tcu::Mat3x4>  { enum { DATATYPE = TYPE_FLOAT_MAT3X4   }; };
 243 template <> struct DataTypeTraits<tcu::Mat4x2>  { enum { DATATYPE = TYPE_FLOAT_MAT4X2   }; };
 244 template <> struct DataTypeTraits<tcu::Mat4x3>  { enum { DATATYPE = TYPE_FLOAT_MAT4X3   }; };
 245 template <> struct DataTypeTraits<tcu::Mat4>    { enum { DATATYPE = TYPE_FLOAT_MAT4             }; };
 246
 247 template <typename T, int Size>
 248 struct DataTypeTraits<tcu::Vector<T, Size> >
 249 {
 250         DE_STATIC_ASSERT(TYPE_FLOAT_VEC4 == TYPE_FLOAT + 3);
 251         DE_STATIC_ASSERT(TYPE_INT_VEC4 == TYPE_INT + 3);
 252         DE_STATIC_ASSERT(TYPE_UINT_VEC4 == TYPE_UINT + 3);
 253         DE_STATIC_ASSERT(TYPE_BOOL_VEC4 == TYPE_BOOL + 3);
 254         enum { DATATYPE = DataTypeTraits<T>::DATATYPE + Size - 1 };
 255 };
 256
 257 template <typename T>
 258 inline DataType dataTypeOf (void) { return DataType(DataTypeTraits<T>::DATATYPE); }
 259
 260 } // glu
 261
 262 #endif // _GLUSHADERUTIL_HPP