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_DOUBLE,
 116         TYPE_DOUBLE_VEC2,
 117         TYPE_DOUBLE_VEC3,
 118         TYPE_DOUBLE_VEC4,
 119         TYPE_DOUBLE_MAT2,
 120         TYPE_DOUBLE_MAT2X3,
 121         TYPE_DOUBLE_MAT2X4,
 122         TYPE_DOUBLE_MAT3X2,
 123         TYPE_DOUBLE_MAT3,
 124         TYPE_DOUBLE_MAT3X4,
 125         TYPE_DOUBLE_MAT4X2,
 126         TYPE_DOUBLE_MAT4X3,
 127         TYPE_DOUBLE_MAT4,
 128
 129         TYPE_INT,
 130         TYPE_INT_VEC2,
 131         TYPE_INT_VEC3,
 132         TYPE_INT_VEC4,
 133
 134         TYPE_UINT,
 135         TYPE_UINT_VEC2,
 136         TYPE_UINT_VEC3,
 137         TYPE_UINT_VEC4,
 138
 139         TYPE_BOOL,
 140         TYPE_BOOL_VEC2,
 141         TYPE_BOOL_VEC3,
 142         TYPE_BOOL_VEC4,
 143
 144         TYPE_SAMPLER_1D,
 145         TYPE_SAMPLER_2D,
 146         TYPE_SAMPLER_CUBE,
 147         TYPE_SAMPLER_1D_ARRAY,
 148         TYPE_SAMPLER_2D_ARRAY,
 149         TYPE_SAMPLER_3D,
 150         TYPE_SAMPLER_CUBE_ARRAY,
 151
 152         TYPE_SAMPLER_1D_SHADOW,
 153         TYPE_SAMPLER_2D_SHADOW,
 154         TYPE_SAMPLER_CUBE_SHADOW,
 155         TYPE_SAMPLER_1D_ARRAY_SHADOW,
 156         TYPE_SAMPLER_2D_ARRAY_SHADOW,
 157         TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
 158
 159         TYPE_INT_SAMPLER_1D,
 160         TYPE_INT_SAMPLER_2D,
 161         TYPE_INT_SAMPLER_CUBE,
 162         TYPE_INT_SAMPLER_1D_ARRAY,
 163         TYPE_INT_SAMPLER_2D_ARRAY,
 164         TYPE_INT_SAMPLER_3D,
 165         TYPE_INT_SAMPLER_CUBE_ARRAY,
 166
 167         TYPE_UINT_SAMPLER_1D,
 168         TYPE_UINT_SAMPLER_2D,
 169         TYPE_UINT_SAMPLER_CUBE,
 170         TYPE_UINT_SAMPLER_1D_ARRAY,
 171         TYPE_UINT_SAMPLER_2D_ARRAY,
 172         TYPE_UINT_SAMPLER_3D,
 173         TYPE_UINT_SAMPLER_CUBE_ARRAY,
 174
 175         TYPE_SAMPLER_2D_MULTISAMPLE,
 176         TYPE_INT_SAMPLER_2D_MULTISAMPLE,
 177         TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
 178
 179         TYPE_IMAGE_2D,
 180         TYPE_IMAGE_CUBE,
 181         TYPE_IMAGE_2D_ARRAY,
 182         TYPE_IMAGE_3D,
 183         TYPE_IMAGE_CUBE_ARRAY,
 184
 185         TYPE_INT_IMAGE_2D,
 186         TYPE_INT_IMAGE_CUBE,
 187         TYPE_INT_IMAGE_2D_ARRAY,
 188         TYPE_INT_IMAGE_3D,
 189         TYPE_INT_IMAGE_CUBE_ARRAY,
 190
 191         TYPE_UINT_IMAGE_2D,
 192         TYPE_UINT_IMAGE_CUBE,
 193         TYPE_UINT_IMAGE_2D_ARRAY,
 194         TYPE_UINT_IMAGE_3D,
 195         TYPE_UINT_IMAGE_CUBE_ARRAY,
 196
 197         TYPE_UINT_ATOMIC_COUNTER,
 198
 199         TYPE_SAMPLER_BUFFER,
 200         TYPE_INT_SAMPLER_BUFFER,
 201         TYPE_UINT_SAMPLER_BUFFER,
 202
 203         TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
 204         TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
 205         TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
 206
 207         TYPE_IMAGE_BUFFER,
 208         TYPE_INT_IMAGE_BUFFER,
 209         TYPE_UINT_IMAGE_BUFFER,
 210
 211         TYPE_LAST
 212 };
 213
 214 const char*             getDataTypeName                         (DataType dataType);
 215 int                             getDataTypeScalarSize           (DataType dataType);
 216 DataType                getDataTypeScalarType           (DataType dataType);
 217 DataType                getDataTypeFloatScalars         (DataType dataType);
 218 DataType                getDataTypeDoubleScalars        (DataType dataType);
 219 DataType                getDataTypeVector                       (DataType scalarType, int size);
 220 DataType                getDataTypeFloatVec                     (int vecSize);
 221 DataType                getDataTypeIntVec                       (int vecSize);
 222 DataType                getDataTypeUintVec                      (int vecSize);
 223 DataType                getDataTypeBoolVec                      (int vecSize);
 224 DataType                getDataTypeMatrix                       (int numCols, int numRows);
 225 DataType                getDataTypeFromGLType           (deUint32 glType);
 226
 227 inline bool             isDataTypeFloatOrVec            (DataType dataType)     { return (dataType >= TYPE_FLOAT)      && (dataType <= TYPE_FLOAT_VEC4);   }
 228 inline bool             isDataTypeDoubleOrDVec          (DataType dataType)     { return (dataType >= TYPE_DOUBLE)     && (dataType <= TYPE_DOUBLE_VEC4);  }
 229 inline bool             isDataTypeMatrix                        (DataType dataType)     { return ((dataType >= TYPE_FLOAT_MAT2) && (dataType <= TYPE_FLOAT_MAT4)) || ((dataType >= TYPE_DOUBLE_MAT2) && (dataType <= TYPE_DOUBLE_MAT4));  }
 230 inline bool             isDataTypeIntOrIVec                     (DataType dataType)     { return (dataType >= TYPE_INT)        && (dataType <= TYPE_INT_VEC4);     }
 231 inline bool             isDataTypeUintOrUVec            (DataType dataType)     { return (dataType >= TYPE_UINT)       && (dataType <= TYPE_UINT_VEC4);    }
 232 inline bool             isDataTypeBoolOrBVec            (DataType dataType)     { return (dataType >= TYPE_BOOL)       && (dataType <= TYPE_BOOL_VEC4);    }
 233 inline bool             isDataTypeScalar                        (DataType dataType) { return (dataType == TYPE_FLOAT) || (dataType == TYPE_DOUBLE) ||(dataType == TYPE_INT) || (dataType == TYPE_UINT) || (dataType == TYPE_BOOL); }
 234 inline bool             isDataTypeVector                        (DataType dataType) { return deInRange32(dataType, TYPE_FLOAT_VEC2, TYPE_FLOAT_VEC4) || deInRange32(dataType, TYPE_DOUBLE_VEC2, TYPE_DOUBLE_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); }
 235 inline bool             isDataTypeScalarOrVector        (DataType dataType) { return deInRange32(dataType, TYPE_FLOAT, TYPE_FLOAT_VEC4) || deInRange32(dataType, TYPE_DOUBLE, TYPE_DOUBLE_VEC4) || deInRange32(dataType, TYPE_INT, TYPE_INT_VEC4) || deInRange32(dataType, TYPE_UINT, TYPE_UINT_VEC4) || deInRange32(dataType, TYPE_BOOL, TYPE_BOOL_VEC4); }
 236 inline bool             isDataTypeSampler                       (DataType dataType)     { return (dataType >= TYPE_SAMPLER_1D) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE); }
 237 inline bool             isDataTypeImage                         (DataType dataType)     { return (dataType >= TYPE_IMAGE_2D) && (dataType <= TYPE_UINT_IMAGE_3D); }
 238 inline bool             isDataTypeSamplerMultisample(DataType dataType) { return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE); }
 239 inline bool             isDataTypeAtomicCounter         (DataType dataType)     { return dataType == TYPE_UINT_ATOMIC_COUNTER; }
 240 inline bool             isDataTypeSamplerBuffer         (DataType dataType)     { return (dataType >= TYPE_SAMPLER_BUFFER) && (dataType <= TYPE_UINT_SAMPLER_BUFFER); }
 241 inline bool             isDataTypeSamplerMSArray        (DataType dataType)     { return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY); }
 242 inline bool             isDataTypeImageBuffer           (DataType dataType)     { return (dataType >= TYPE_IMAGE_BUFFER) && (dataType <= TYPE_UINT_IMAGE_BUFFER); }
 243
 244 int                             getDataTypeMatrixNumRows        (DataType dataType);
 245 int                             getDataTypeMatrixNumColumns     (DataType dataType);
 246
 247 int                             getDataTypeNumLocations         (DataType dataType);
 248 int                             getDataTypeNumComponents        (DataType dataType);
 249
 250 template <typename T>
 251 struct DataTypeTraits;
 252
 253 template <> struct DataTypeTraits<float>                { enum { DATATYPE = TYPE_FLOAT                  }; };
 254 template <> struct DataTypeTraits<bool>                 { enum { DATATYPE = TYPE_BOOL                   }; };
 255 template <> struct DataTypeTraits<int>                  { enum { DATATYPE = TYPE_INT                    }; };
 256 template <> struct DataTypeTraits<deUint32>             { enum { DATATYPE = TYPE_UINT                   }; };
 257 template <> struct DataTypeTraits<tcu::Mat2>    { enum { DATATYPE = TYPE_FLOAT_MAT2             }; };
 258 template <> struct DataTypeTraits<tcu::Mat2x3>  { enum { DATATYPE = TYPE_FLOAT_MAT2X3   }; };
 259 template <> struct DataTypeTraits<tcu::Mat2x4>  { enum { DATATYPE = TYPE_FLOAT_MAT2X4   }; };
 260 template <> struct DataTypeTraits<tcu::Mat3x2>  { enum { DATATYPE = TYPE_FLOAT_MAT3X2   }; };
 261 template <> struct DataTypeTraits<tcu::Mat3>    { enum { DATATYPE = TYPE_FLOAT_MAT3             }; };
 262 template <> struct DataTypeTraits<tcu::Mat3x4>  { enum { DATATYPE = TYPE_FLOAT_MAT3X4   }; };
 263 template <> struct DataTypeTraits<tcu::Mat4x2>  { enum { DATATYPE = TYPE_FLOAT_MAT4X2   }; };
 264 template <> struct DataTypeTraits<tcu::Mat4x3>  { enum { DATATYPE = TYPE_FLOAT_MAT4X3   }; };
 265 template <> struct DataTypeTraits<tcu::Mat4>    { enum { DATATYPE = TYPE_FLOAT_MAT4             }; };
 266
 267 template <typename T, int Size>
 268 struct DataTypeTraits<tcu::Vector<T, Size> >
 269 {
 270         DE_STATIC_ASSERT(TYPE_FLOAT_VEC4 == TYPE_FLOAT + 3);
 271         DE_STATIC_ASSERT(TYPE_INT_VEC4 == TYPE_INT + 3);
 272         DE_STATIC_ASSERT(TYPE_UINT_VEC4 == TYPE_UINT + 3);
 273         DE_STATIC_ASSERT(TYPE_BOOL_VEC4 == TYPE_BOOL + 3);
 274         enum { DATATYPE = DataTypeTraits<T>::DATATYPE + Size - 1 };
 275 };
 276
 277 template <typename T>
 278 inline DataType dataTypeOf (void) { return DataType(DataTypeTraits<T>::DATATYPE); }
 279
 280 } // glu
 281
 282 #endif // _GLUSHADERUTIL_HPP