framework/opengl/gluShaderUtil.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   3  * ------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader utilities.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluShaderUtil.hpp"
  25 #include "glwEnums.hpp"
  26 #include "deArrayUtil.hpp"
  27
  28 namespace glu
  29 {
  30
  31 // ShadingLanguageVersion
  32
  33 const char* getGLSLVersionName (GLSLVersion version)
  34 {
  35         static const char* s_names[] =
  36         {
  37                 "GLSL ES 1.0",
  38                 "GLSL ES 3.0",
  39                 "GLSL ES 3.1",
  40                 "GLSL ES 3.2",
  41                 "GLSL 1.3",
  42                 "GLSL 1.4",
  43                 "GLSL 1.5",
  44                 "GLSL 3.3",
  45                 "GLSL 4.0",
  46                 "GLSL 4.1",
  47                 "GLSL 4.2",
  48                 "GLSL 4.3",
  49                 "GLSL 4.4",
  50                 "GLSL 4.5",
  51         };
  52
  53         return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_names, version);
  54 }
  55
  56 const char* getGLSLVersionDeclaration (GLSLVersion version)
  57 {
  58         static const char* s_decl[] =
  59         {
  60                 "#version 100",
  61                 "#version 300 es",
  62                 "#version 310 es",
  63                 "#version 320 es",
  64                 "#version 130",
  65                 "#version 140",
  66                 "#version 150",
  67                 "#version 330",
  68                 "#version 400",
  69                 "#version 410",
  70                 "#version 420",
  71                 "#version 430",
  72                 "#version 440",
  73                 "#version 450",
  74         };
  75
  76         return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_decl, version);
  77 }
  78
  79 bool glslVersionUsesInOutQualifiers (GLSLVersion version)
  80 {
  81         return de::inRange<int>(version, GLSL_VERSION_300_ES, GLSL_VERSION_320_ES) || de::inRange<int>(version, GLSL_VERSION_330, GLSL_VERSION_430);
  82 }
  83
  84 bool glslVersionIsES (GLSLVersion version)
  85 {
  86         DE_STATIC_ASSERT(GLSL_VERSION_LAST == 14);
  87         DE_ASSERT(version != GLSL_VERSION_LAST);
  88
  89         if (version == GLSL_VERSION_100_ES      ||
  90                 version == GLSL_VERSION_300_ES  ||
  91                 version == GLSL_VERSION_310_ES  ||
  92                 version == GLSL_VERSION_320_ES)
  93                 return true;
  94         else
  95                 return false;
  96 }
  97
  98 // \todo [2014-10-06 pyry] Export this.
  99 static ApiType getMinAPIForGLSLVersion (GLSLVersion version)
 100 {
 101         static const ApiType s_minApi[] =
 102         {
 103                 ApiType::es(2,0),
 104                 ApiType::es(3,0),
 105                 ApiType::es(3,1),
 106                 ApiType::es(3,2),
 107                 ApiType::core(3,0),
 108                 ApiType::core(3,1),
 109                 ApiType::core(3,2),
 110                 ApiType::core(3,3),
 111                 ApiType::core(4,0),
 112                 ApiType::core(4,1),
 113                 ApiType::core(4,2),
 114                 ApiType::core(4,3),
 115                 ApiType::core(4,4),
 116                 ApiType::core(4,5),
 117         };
 118
 119         return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_minApi, version);
 120 }
 121
 122 bool isGLSLVersionSupported (ContextType type, GLSLVersion version)
 123 {
 124         return contextSupports(type, getMinAPIForGLSLVersion(version));
 125 }
 126
 127 GLSLVersion getContextTypeGLSLVersion (ContextType type)
 128 {
 129         // \note From newer to older
 130         for (int version = GLSL_VERSION_LAST-1; version >= 0; version--)
 131         {
 132                 if (isGLSLVersionSupported(type, GLSLVersion(version)))
 133                         return GLSLVersion(version);
 134         }
 135
 136         DE_ASSERT(false);
 137         return GLSL_VERSION_LAST;
 138 }
 139
 140 // ShaderType
 141
 142 const char* getShaderTypeName (ShaderType shaderType)
 143 {
 144         static const char* s_names[] =
 145         {
 146                 "vertex",
 147                 "fragment",
 148                 "geometry",
 149                 "tess_control",
 150                 "tess_eval",
 151                 "compute",
 152         };
 153
 154         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == SHADERTYPE_LAST);
 155         DE_ASSERT(deInBounds32((int)shaderType, 0, SHADERTYPE_LAST));
 156         return s_names[(int)shaderType];
 157 }
 158
 159 // Precision
 160
 161 const char* getPrecisionName (Precision precision)
 162 {
 163         static const char* s_names[] =
 164         {
 165                 "lowp",
 166                 "mediump",
 167                 "highp"
 168         };
 169
 170         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == PRECISION_LAST);
 171         DE_ASSERT(deInBounds32((int)precision, 0, PRECISION_LAST));
 172         return s_names[(int)precision];
 173 }
 174
 175 // DataType
 176
 177 const char* getDataTypeName (DataType dataType)
 178 {
 179         static const char* s_names[] =
 180         {
 181                 "invalid",
 182                 "float",
 183                 "vec2",
 184                 "vec3",
 185                 "vec4",
 186                 "mat2",
 187                 "mat2x3",
 188                 "mat2x4",
 189                 "mat3x2",
 190                 "mat3",
 191                 "mat3x4",
 192                 "mat4x2",
 193                 "mat4x3",
 194                 "mat4",
 195                 "double",
 196                 "dvec2",
 197                 "dvec3",
 198                 "dvec4",
 199                 "dmat2",
 200                 "dmat2x3",
 201                 "dmat2x4",
 202                 "dmat3x2",
 203                 "dmat3",
 204                 "dmat3x4",
 205                 "dmat4x2",
 206                 "dmat4x3",
 207                 "dmat4",
 208                 "int",
 209                 "ivec2",
 210                 "ivec3",
 211                 "ivec4",
 212                 "uint",
 213                 "uvec2",
 214                 "uvec3",
 215                 "uvec4",
 216                 "bool",
 217                 "bvec2",
 218                 "bvec3",
 219                 "bvec4",
 220                 "sampler1D",
 221                 "sampler2D",
 222                 "samplerCube",
 223                 "sampler1DArray",
 224                 "sampler2DArray",
 225                 "sampler3D",
 226                 "samplerCubeArray",
 227                 "sampler1DShadow",
 228                 "sampler2DShadow",
 229                 "samplerCubeShadow",
 230                 "sampler1DArrayShadow",
 231                 "sampler2DArrayShadow",
 232                 "samplerCubeArrayShadow",
 233                 "isampler1D",
 234                 "isampler2D",
 235                 "isamplerCube",
 236                 "isampler1DArray",
 237                 "isampler2DArray",
 238                 "isampler3D",
 239                 "isamplerCubeArray",
 240                 "usampler1D",
 241                 "usampler2D",
 242                 "usamplerCube",
 243                 "usampler1DArray",
 244                 "usampler2DArray",
 245                 "usampler3D",
 246                 "usamplerCubeArray",
 247                 "sampler2DMS",
 248                 "isampler2DMS",
 249                 "usampler2DMS",
 250                 "image2D",
 251                 "imageCube",
 252                 "image2DArray",
 253                 "image3D",
 254                 "imageCubeArray",
 255                 "iimage2D",
 256                 "iimageCube",
 257                 "iimage2DArray",
 258                 "iimage3D",
 259                 "iimageCubeArray",
 260                 "uimage2D",
 261                 "uimageCube",
 262                 "uimage2DArray",
 263                 "uimage3D",
 264                 "uimageCubeArray",
 265                 "atomic_uint",
 266                 "samplerBuffer",
 267                 "isamplerBuffer",
 268                 "usamplerBuffer",
 269                 "sampler2DMSArray",
 270                 "isampler2DMSArray",
 271                 "usampler2DMSArray",
 272                 "imageBuffer",
 273                 "iimageBuffer",
 274                 "uimageBuffer",
 275         };
 276
 277         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
 278         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
 279         return s_names[(int)dataType];
 280 }
 281
 282 int getDataTypeScalarSize (DataType dataType)
 283 {
 284         static const int s_sizes[] =
 285         {
 286                 -1,             // invalid
 287                 1,              // float
 288                 2,              // vec2
 289                 3,              // vec3
 290                 4,              // vec4
 291                 4,              // mat2
 292                 6,              // mat2x3
 293                 8,              // mat2x4
 294                 6,              // mat3x2
 295                 9,              // mat3
 296                 12,             // mat3x4
 297                 8,              // mat4x2
 298                 12,             // mat4x3
 299                 16,             // mat4
 300                 1,              // double
 301                 2,              // dvec2
 302                 3,              // dvec3
 303                 4,              // dvec4
 304                 4,              // dmat2
 305                 6,              // dmat2x3
 306                 8,              // dmat2x4
 307                 6,              // dmat3x2
 308                 9,              // dmat3
 309                 12,             // dmat3x4
 310                 8,              // dmat4x2
 311                 12,             // dmat4x3
 312                 16,             // dmat4
 313                 1,              // int
 314                 2,              // ivec2
 315                 3,              // ivec3
 316                 4,              // ivec4
 317                 1,              // uint
 318                 2,              // uvec2
 319                 3,              // uvec3
 320                 4,              // uvec4
 321                 1,              // bool
 322                 2,              // bvec2
 323                 3,              // bvec3
 324                 4,              // bvec4
 325                 1,              // sampler1D
 326                 1,              // sampler2D
 327                 1,              // samplerCube
 328                 1,              // sampler1DArray
 329                 1,              // sampler2DArray
 330                 1,              // sampler3D
 331                 1,              // samplerCubeArray
 332                 1,              // sampler1DShadow
 333                 1,              // sampler2DShadow
 334                 1,              // samplerCubeShadow
 335                 1,              // sampler1DArrayShadow
 336                 1,              // sampler2DArrayShadow
 337                 1,              // samplerCubeArrayShadow
 338                 1,              // isampler1D
 339                 1,              // isampler2D
 340                 1,              // isamplerCube
 341                 1,              // isampler1DArray
 342                 1,              // isampler2DArray
 343                 1,              // isampler3D
 344                 1,              // isamplerCubeArray
 345                 1,              // usampler1D
 346                 1,              // usampler2D
 347                 1,              // usamplerCube
 348                 1,              // usampler1DArray
 349                 1,              // usampler2DArray
 350                 1,              // usampler3D
 351                 1,              // usamplerCubeArray
 352                 1,              // sampler2DMS
 353                 1,              // isampler2DMS
 354                 1,              // usampler2DMS
 355                 1,              // image2D
 356                 1,              // imageCube
 357                 1,              // image2DArray
 358                 1,              // image3D
 359                 1,              // imageCubeArray
 360                 1,              // iimage2D
 361                 1,              // iimageCube
 362                 1,              // iimage2DArray
 363                 1,              // iimage3D
 364                 1,              // iimageCubeArray
 365                 1,              // uimage2D
 366                 1,              // uimageCube
 367                 1,              // uimage2DArray
 368                 1,              // uimage3D
 369                 1,              // uimageCubeArray
 370                 1,              // atomic_uint
 371                 1,              // samplerBuffer
 372                 1,              // isamplerBuffer
 373                 1,              // usamplerBuffer
 374                 1,              // sampler2DMSArray
 375                 1,              // isampler2DMSArray
 376                 1,              // usampler2DMSArray
 377                 1,              // imageBuffer
 378                 1,              // iimageBuffer
 379                 1,              // uimageBuffer
 380         };
 381
 382         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
 383         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
 384         return s_sizes[(int)dataType];
 385 }
 386
 387 DataType getDataTypeScalarType (DataType dataType)
 388 {
 389         static const DataType s_scalarTypes[] =
 390         {
 391                 TYPE_INVALID,                                                   // invalid
 392                 TYPE_FLOAT,                                                             // float
 393                 TYPE_FLOAT,                                                             // vec2
 394                 TYPE_FLOAT,                                                             // vec3
 395                 TYPE_FLOAT,                                                             // vec4
 396                 TYPE_FLOAT,                                                             // mat2
 397                 TYPE_FLOAT,                                                             // mat2x3
 398                 TYPE_FLOAT,                                                             // mat2x4
 399                 TYPE_FLOAT,                                                             // mat3x2
 400                 TYPE_FLOAT,                                                             // mat3
 401                 TYPE_FLOAT,                                                             // mat3x4
 402                 TYPE_FLOAT,                                                             // mat4x2
 403                 TYPE_FLOAT,                                                             // mat4x3
 404                 TYPE_FLOAT,                                                             // mat4
 405                 TYPE_DOUBLE,                                                    // double
 406                 TYPE_DOUBLE,                                                    // dvec2
 407                 TYPE_DOUBLE,                                                    // dvec3
 408                 TYPE_DOUBLE,                                                    // dvec4
 409                 TYPE_DOUBLE,                                                    // dmat2
 410                 TYPE_DOUBLE,                                                    // dmat2x3
 411                 TYPE_DOUBLE,                                                    // dmat2x4
 412                 TYPE_DOUBLE,                                                    // dmat3x2
 413                 TYPE_DOUBLE,                                                    // dmat3
 414                 TYPE_DOUBLE,                                                    // dmat3x4
 415                 TYPE_DOUBLE,                                                    // dmat4x2
 416                 TYPE_DOUBLE,                                                    // dmat4x3
 417                 TYPE_DOUBLE,                                                    // dmat4
 418                 TYPE_INT,                                                               // int
 419                 TYPE_INT,                                                               // ivec2
 420                 TYPE_INT,                                                               // ivec3
 421                 TYPE_INT,                                                               // ivec4
 422                 TYPE_UINT,                                                              // uint
 423                 TYPE_UINT,                                                              // uvec2
 424                 TYPE_UINT,                                                              // uvec3
 425                 TYPE_UINT,                                                              // uvec4
 426                 TYPE_BOOL,                                                              // bool
 427                 TYPE_BOOL,                                                              // bvec2
 428                 TYPE_BOOL,                                                              // bvec3
 429                 TYPE_BOOL,                                                              // bvec4
 430                 TYPE_SAMPLER_1D,                                                // sampler1D
 431                 TYPE_SAMPLER_2D,                                                // sampler2D
 432                 TYPE_SAMPLER_CUBE,                                              // samplerCube
 433                 TYPE_SAMPLER_1D_ARRAY,                                  // sampler1DArray
 434                 TYPE_SAMPLER_2D_ARRAY,                                  // sampler2DArray
 435                 TYPE_SAMPLER_3D,                                                // sampler3D
 436                 TYPE_SAMPLER_CUBE_ARRAY,                                // samplerCubeArray
 437                 TYPE_SAMPLER_1D_SHADOW,                                 // sampler1DShadow
 438                 TYPE_SAMPLER_2D_SHADOW,                                 // sampler2DShadow
 439                 TYPE_SAMPLER_CUBE_SHADOW,                               // samplerCubeShadow
 440                 TYPE_SAMPLER_1D_ARRAY_SHADOW,                   // sampler1DArrayShadow
 441                 TYPE_SAMPLER_2D_ARRAY_SHADOW,                   // sampler2DArrayShadow
 442                 TYPE_SAMPLER_CUBE_ARRAY_SHADOW,                 // samplerCubeArrayShadow
 443                 TYPE_INT_SAMPLER_1D,                                    // isampler1D
 444                 TYPE_INT_SAMPLER_2D,                                    // isampler2D
 445                 TYPE_INT_SAMPLER_CUBE,                                  // isamplerCube
 446                 TYPE_INT_SAMPLER_1D_ARRAY,                              // isampler1DArray
 447                 TYPE_INT_SAMPLER_2D_ARRAY,                              // isampler2DArray
 448                 TYPE_INT_SAMPLER_3D,                                    // isampler3D
 449                 TYPE_INT_SAMPLER_CUBE_ARRAY,                    // isamplerCubeArray
 450                 TYPE_UINT_SAMPLER_1D,                                   // usampler1D
 451                 TYPE_UINT_SAMPLER_2D,                                   // usampler2D
 452                 TYPE_UINT_SAMPLER_CUBE,                                 // usamplerCube
 453                 TYPE_UINT_SAMPLER_1D_ARRAY,                             // usampler1DArray
 454                 TYPE_UINT_SAMPLER_2D_ARRAY,                             // usampler2DArray
 455                 TYPE_UINT_SAMPLER_3D,                                   // usampler3D
 456                 TYPE_UINT_SAMPLER_CUBE_ARRAY,                   // usamplerCubeArray
 457                 TYPE_SAMPLER_2D_MULTISAMPLE,                    // sampler2DMS
 458                 TYPE_INT_SAMPLER_2D_MULTISAMPLE,                // isampler2DMS
 459                 TYPE_UINT_SAMPLER_2D_MULTISAMPLE,               // usampler2DMS
 460                 TYPE_IMAGE_2D,                                                  // image2D
 461                 TYPE_IMAGE_CUBE,                                                // imageCube
 462                 TYPE_IMAGE_2D_ARRAY,                                    // image2DArray
 463                 TYPE_IMAGE_3D,                                                  // image3D
 464                 TYPE_IMAGE_CUBE_ARRAY,                                  // imageCubeArray
 465                 TYPE_INT_IMAGE_2D,                                              // iimage2D
 466                 TYPE_INT_IMAGE_CUBE,                                    // iimageCube
 467                 TYPE_INT_IMAGE_2D_ARRAY,                                // iimage2DArray
 468                 TYPE_INT_IMAGE_3D,                                              // iimage3D
 469                 TYPE_INT_IMAGE_CUBE_ARRAY,                              // iimageCubeArray
 470                 TYPE_UINT_IMAGE_2D,                                             // uimage2D
 471                 TYPE_UINT_IMAGE_CUBE,                                   // uimageCube
 472                 TYPE_UINT_IMAGE_2D_ARRAY,                               // uimage2DArray
 473                 TYPE_UINT_IMAGE_3D,                                             // uimage3D
 474                 TYPE_UINT_IMAGE_CUBE_ARRAY,                             // uimageCubeArray
 475                 TYPE_UINT_ATOMIC_COUNTER,                               // atomic_uint
 476                 TYPE_SAMPLER_BUFFER,                                    // samplerBuffer
 477                 TYPE_INT_SAMPLER_BUFFER,                                // isamplerBuffer
 478                 TYPE_UINT_SAMPLER_BUFFER,                               // usamplerBuffer
 479                 TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,              // sampler2DMSArray
 480                 TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,  // isampler2DMSArray
 481                 TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, // usampler2DMSArray
 482                 TYPE_IMAGE_BUFFER,                                              // imageBuffer
 483                 TYPE_INT_IMAGE_BUFFER,                                  // iimageBuffer
 484                 TYPE_UINT_IMAGE_BUFFER,                                 // uimageBuffer
 485         };
 486
 487         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
 488         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
 489         return s_scalarTypes[(int)dataType];
 490 }
 491
 492 DataType getDataTypeFloatScalars (DataType dataType)
 493 {
 494         static const DataType s_floatTypes[] =
 495         {
 496                 TYPE_INVALID,           // invalid
 497                 TYPE_FLOAT,                     // float
 498                 TYPE_FLOAT_VEC2,        // vec2
 499                 TYPE_FLOAT_VEC3,        // vec3
 500                 TYPE_FLOAT_VEC4,        // vec4
 501                 TYPE_FLOAT_MAT2,        // mat2
 502                 TYPE_FLOAT_MAT2X3,      // mat2x3
 503                 TYPE_FLOAT_MAT2X4,      // mat2x4
 504                 TYPE_FLOAT_MAT3X2,      // mat3x2
 505                 TYPE_FLOAT_MAT3,        // mat3
 506                 TYPE_FLOAT_MAT3X4,      // mat3x4
 507                 TYPE_FLOAT_MAT4X2,      // mat4x2
 508                 TYPE_FLOAT_MAT4X3,      // mat4x3
 509                 TYPE_FLOAT_MAT4,        // mat4
 510                 TYPE_FLOAT,                     // double
 511                 TYPE_FLOAT_VEC2,        // dvec2
 512                 TYPE_FLOAT_VEC3,        // dvec3
 513                 TYPE_FLOAT_VEC4,        // dvec4
 514                 TYPE_FLOAT_MAT2,        // dmat2
 515                 TYPE_FLOAT_MAT2X3,      // dmat2x3
 516                 TYPE_FLOAT_MAT2X4,      // dmat2x4
 517                 TYPE_FLOAT_MAT3X2,      // dmat3x2
 518                 TYPE_FLOAT_MAT3,        // dmat3
 519                 TYPE_FLOAT_MAT3X4,      // dmat3x4
 520                 TYPE_FLOAT_MAT4X2,      // dmat4x2
 521                 TYPE_FLOAT_MAT4X3,      // dmat4x3
 522                 TYPE_FLOAT_MAT4,        // dmat4
 523                 TYPE_FLOAT,                     // int
 524                 TYPE_FLOAT_VEC2,        // ivec2
 525                 TYPE_FLOAT_VEC3,        // ivec3
 526                 TYPE_FLOAT_VEC4,        // ivec4
 527                 TYPE_FLOAT,                     // uint
 528                 TYPE_FLOAT_VEC2,        // uvec2
 529                 TYPE_FLOAT_VEC3,        // uvec3
 530                 TYPE_FLOAT_VEC4,        // uvec4
 531                 TYPE_FLOAT,                     // bool
 532                 TYPE_FLOAT_VEC2,        // bvec2
 533                 TYPE_FLOAT_VEC3,        // bvec3
 534                 TYPE_FLOAT_VEC4,        // bvec4
 535                 TYPE_INVALID,           // sampler1D
 536                 TYPE_INVALID,           // sampler2D
 537                 TYPE_INVALID,           // samplerCube
 538                 TYPE_INVALID,           // sampler1DArray
 539                 TYPE_INVALID,           // sampler2DArray
 540                 TYPE_INVALID,           // sampler3D
 541                 TYPE_INVALID,           // samplerCubeArray
 542                 TYPE_INVALID,           // sampler1DShadow
 543                 TYPE_INVALID,           // sampler2DShadow
 544                 TYPE_INVALID,           // samplerCubeShadow
 545                 TYPE_INVALID,           // sampler1DArrayShadow
 546                 TYPE_INVALID,           // sampler2DArrayShadow
 547                 TYPE_INVALID,           // samplerCubeArrayShadow
 548                 TYPE_INVALID,           // isampler1D
 549                 TYPE_INVALID,           // isampler2D
 550                 TYPE_INVALID,           // isamplerCube
 551                 TYPE_INVALID,           // isampler1DArray
 552                 TYPE_INVALID,           // isampler2DArray
 553                 TYPE_INVALID,           // isampler3D
 554                 TYPE_INVALID,           // isamplerCubeArray
 555                 TYPE_INVALID,           // usampler1D
 556                 TYPE_INVALID,           // usampler2D
 557                 TYPE_INVALID,           // usamplerCube
 558                 TYPE_INVALID,           // usampler1DArray
 559                 TYPE_INVALID,           // usampler2DArray
 560                 TYPE_INVALID,           // usampler3D
 561                 TYPE_INVALID,           // usamplerCubeArray
 562                 TYPE_INVALID,           // sampler2DMS
 563                 TYPE_INVALID,           // isampler2DMS
 564                 TYPE_INVALID,           // usampler2DMS
 565                 TYPE_INVALID,           // image2D
 566                 TYPE_INVALID,           // imageCube
 567                 TYPE_INVALID,           // image2DArray
 568                 TYPE_INVALID,           // image3D
 569                 TYPE_INVALID,           // imageCubeArray
 570                 TYPE_INVALID,           // iimage2D
 571                 TYPE_INVALID,           // iimageCube
 572                 TYPE_INVALID,           // iimage2DArray
 573                 TYPE_INVALID,           // iimage3D
 574                 TYPE_INVALID,           // iimageCubeArray
 575                 TYPE_INVALID,           // uimage2D
 576                 TYPE_INVALID,           // uimageCube
 577                 TYPE_INVALID,           // uimage2DArray
 578                 TYPE_INVALID,           // uimage3D
 579                 TYPE_INVALID,           // uimageCubeArray
 580                 TYPE_INVALID,           // atomic_uint
 581                 TYPE_INVALID,           // samplerBuffer
 582                 TYPE_INVALID,           // isamplerBuffer
 583                 TYPE_INVALID,           // usamplerBuffer
 584                 TYPE_INVALID,           // sampler2DMSArray
 585                 TYPE_INVALID,           // isampler2DMSArray
 586                 TYPE_INVALID,           // usampler2DMSArray
 587                 TYPE_INVALID,           // imageBuffer
 588                 TYPE_INVALID,           // iimageBuffer
 589                 TYPE_INVALID,           // uimageBuffer
 590         };
 591
 592         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
 593         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
 594         return s_floatTypes[(int)dataType];
 595 }
 596
 597 DataType getDataTypeDoubleScalars (DataType dataType)
 598 {
 599         static const DataType s_doubleTypes[] =
 600         {
 601                 TYPE_INVALID,           // invalid
 602                 TYPE_DOUBLE,            // float
 603                 TYPE_DOUBLE_VEC2,       // vec2
 604                 TYPE_DOUBLE_VEC3,       // vec3
 605                 TYPE_DOUBLE_VEC4,       // vec4
 606                 TYPE_DOUBLE_MAT2,       // mat2
 607                 TYPE_DOUBLE_MAT2X3,     // mat2x3
 608                 TYPE_DOUBLE_MAT2X4,     // mat2x4
 609                 TYPE_DOUBLE_MAT3X2,     // mat3x2
 610                 TYPE_DOUBLE_MAT3,       // mat3
 611                 TYPE_DOUBLE_MAT3X4,     // mat3x4
 612                 TYPE_DOUBLE_MAT4X2,     // mat4x2
 613                 TYPE_DOUBLE_MAT4X3,     // mat4x3
 614                 TYPE_DOUBLE_MAT4,       // mat4
 615                 TYPE_DOUBLE,            // double
 616                 TYPE_DOUBLE_VEC2,       // dvec2
 617                 TYPE_DOUBLE_VEC3,       // dvec3
 618                 TYPE_DOUBLE_VEC4,       // dvec4
 619                 TYPE_DOUBLE_MAT2,       // dmat2
 620                 TYPE_DOUBLE_MAT2X3,     // dmat2x3
 621                 TYPE_DOUBLE_MAT2X4,     // dmat2x4
 622                 TYPE_DOUBLE_MAT3X2,     // dmat3x2
 623                 TYPE_DOUBLE_MAT3,       // dmat3
 624                 TYPE_DOUBLE_MAT3X4,     // dmat3x4
 625                 TYPE_DOUBLE_MAT4X2,     // dmat4x2
 626                 TYPE_DOUBLE_MAT4X3,     // dmat4x3
 627                 TYPE_DOUBLE_MAT4,       // dmat4
 628                 TYPE_DOUBLE,            // int
 629                 TYPE_DOUBLE_VEC2,       // ivec2
 630                 TYPE_DOUBLE_VEC3,       // ivec3
 631                 TYPE_DOUBLE_VEC4,       // ivec4
 632                 TYPE_DOUBLE,            // uint
 633                 TYPE_DOUBLE_VEC2,       // uvec2
 634                 TYPE_DOUBLE_VEC3,       // uvec3
 635                 TYPE_DOUBLE_VEC4,       // uvec4
 636                 TYPE_DOUBLE,            // bool
 637                 TYPE_DOUBLE_VEC2,       // bvec2
 638                 TYPE_DOUBLE_VEC3,       // bvec3
 639                 TYPE_DOUBLE_VEC4,       // bvec4
 640                 TYPE_INVALID,           // sampler1D
 641                 TYPE_INVALID,           // sampler2D
 642                 TYPE_INVALID,           // samplerCube
 643                 TYPE_INVALID,           // sampler1DArray
 644                 TYPE_INVALID,           // sampler2DArray
 645                 TYPE_INVALID,           // sampler3D
 646                 TYPE_INVALID,           // samplerCubeArray
 647                 TYPE_INVALID,           // sampler1DShadow
 648                 TYPE_INVALID,           // sampler2DShadow
 649                 TYPE_INVALID,           // samplerCubeShadow
 650                 TYPE_INVALID,           // sampler1DArrayShadow
 651                 TYPE_INVALID,           // sampler2DArrayShadow
 652                 TYPE_INVALID,           // samplerCubeArrayShadow
 653                 TYPE_INVALID,           // isampler1D
 654                 TYPE_INVALID,           // isampler2D
 655                 TYPE_INVALID,           // isamplerCube
 656                 TYPE_INVALID,           // isampler1DArray
 657                 TYPE_INVALID,           // isampler2DArray
 658                 TYPE_INVALID,           // isampler3D
 659                 TYPE_INVALID,           // isamplerCubeArray
 660                 TYPE_INVALID,           // usampler1D
 661                 TYPE_INVALID,           // usampler2D
 662                 TYPE_INVALID,           // usamplerCube
 663                 TYPE_INVALID,           // usampler1DArray
 664                 TYPE_INVALID,           // usampler2DArray
 665                 TYPE_INVALID,           // usampler3D
 666                 TYPE_INVALID,           // usamplerCubeArray
 667                 TYPE_INVALID,           // sampler2DMS
 668                 TYPE_INVALID,           // isampler2DMS
 669                 TYPE_INVALID,           // usampler2DMS
 670                 TYPE_INVALID,           // image2D
 671                 TYPE_INVALID,           // imageCube
 672                 TYPE_INVALID,           // image2DArray
 673                 TYPE_INVALID,           // image3D
 674                 TYPE_INVALID,           // imageCubeArray
 675                 TYPE_INVALID,           // iimage2D
 676                 TYPE_INVALID,           // iimageCube
 677                 TYPE_INVALID,           // iimage2DArray
 678                 TYPE_INVALID,           // iimage3D
 679                 TYPE_INVALID,           // iimageCubeArray
 680                 TYPE_INVALID,           // uimage2D
 681                 TYPE_INVALID,           // uimageCube
 682                 TYPE_INVALID,           // uimage2DArray
 683                 TYPE_INVALID,           // uimage3D
 684                 TYPE_INVALID,           // uimageCubeArray
 685                 TYPE_INVALID,           // atomic_uint
 686                 TYPE_INVALID,           // samplerBuffer
 687                 TYPE_INVALID,           // isamplerBuffer
 688                 TYPE_INVALID,           // usamplerBuffer
 689                 TYPE_INVALID,           // sampler2DMSArray
 690                 TYPE_INVALID,           // isampler2DMSArray
 691                 TYPE_INVALID,           // usampler2DMSArray
 692                 TYPE_INVALID,           // imageBuffer
 693                 TYPE_INVALID,           // iimageBuffer
 694                 TYPE_INVALID,           // uimageBuffer
 695         };
 696
 697         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_doubleTypes) == TYPE_LAST);
 698         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_doubleTypes)));
 699         return s_doubleTypes[(int)dataType];
 700 }
 701
 702 DataType getDataTypeVector (DataType scalarType, int size)
 703 {
 704         DE_ASSERT(deInRange32(size, 1, 4));
 705         switch (scalarType)
 706         {
 707                 case TYPE_FLOAT:
 708                 case TYPE_DOUBLE:
 709                 case TYPE_INT:
 710                 case TYPE_UINT:
 711                 case TYPE_BOOL:
 712                         return (DataType)((int)scalarType + size - 1);
 713                 default:
 714                         return TYPE_INVALID;
 715         }
 716 }
 717
 718 DataType getDataTypeFloatVec (int vecSize)
 719 {
 720         return getDataTypeVector(TYPE_FLOAT, vecSize);
 721 }
 722
 723 DataType getDataTypeIntVec (int vecSize)
 724 {
 725         return getDataTypeVector(TYPE_INT, vecSize);
 726 }
 727
 728 DataType getDataTypeUintVec (int vecSize)
 729 {
 730         return getDataTypeVector(TYPE_UINT, vecSize);
 731 }
 732
 733 DataType getDataTypeBoolVec (int vecSize)
 734 {
 735         return getDataTypeVector(TYPE_BOOL, vecSize);
 736 }
 737
 738 DataType getDataTypeMatrix (int numCols, int numRows)
 739 {
 740         DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
 741         return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols-2)*3 + (numRows-2));
 742 }
 743
 744 int getDataTypeMatrixNumRows (DataType dataType)
 745 {
 746         switch (dataType)
 747         {
 748                 case TYPE_FLOAT_MAT2:           return 2;
 749                 case TYPE_FLOAT_MAT2X3:         return 3;
 750                 case TYPE_FLOAT_MAT2X4:         return 4;
 751                 case TYPE_FLOAT_MAT3X2:         return 2;
 752                 case TYPE_FLOAT_MAT3:           return 3;
 753                 case TYPE_FLOAT_MAT3X4:         return 4;
 754                 case TYPE_FLOAT_MAT4X2:         return 2;
 755                 case TYPE_FLOAT_MAT4X3:         return 3;
 756                 case TYPE_FLOAT_MAT4:           return 4;
 757                 case TYPE_DOUBLE_MAT2:          return 2;
 758                 case TYPE_DOUBLE_MAT2X3:        return 3;
 759                 case TYPE_DOUBLE_MAT2X4:        return 4;
 760                 case TYPE_DOUBLE_MAT3X2:        return 2;
 761                 case TYPE_DOUBLE_MAT3:          return 3;
 762                 case TYPE_DOUBLE_MAT3X4:        return 4;
 763                 case TYPE_DOUBLE_MAT4X2:        return 2;
 764                 case TYPE_DOUBLE_MAT4X3:        return 3;
 765                 case TYPE_DOUBLE_MAT4:          return 4;
 766                 default:
 767                         DE_ASSERT(false);
 768                         return 0;
 769         }
 770 }
 771
 772 int getDataTypeMatrixNumColumns (DataType dataType)
 773 {
 774         switch (dataType)
 775         {
 776                 case TYPE_FLOAT_MAT2:           return 2;
 777                 case TYPE_FLOAT_MAT2X3:         return 2;
 778                 case TYPE_FLOAT_MAT2X4:         return 2;
 779                 case TYPE_FLOAT_MAT3X2:         return 3;
 780                 case TYPE_FLOAT_MAT3:           return 3;
 781                 case TYPE_FLOAT_MAT3X4:         return 3;
 782                 case TYPE_FLOAT_MAT4X2:         return 4;
 783                 case TYPE_FLOAT_MAT4X3:         return 4;
 784                 case TYPE_FLOAT_MAT4:           return 4;
 785                 case TYPE_DOUBLE_MAT2:          return 2;
 786                 case TYPE_DOUBLE_MAT2X3:        return 2;
 787                 case TYPE_DOUBLE_MAT2X4:        return 2;
 788                 case TYPE_DOUBLE_MAT3X2:        return 3;
 789                 case TYPE_DOUBLE_MAT3:          return 3;
 790                 case TYPE_DOUBLE_MAT3X4:        return 3;
 791                 case TYPE_DOUBLE_MAT4X2:        return 4;
 792                 case TYPE_DOUBLE_MAT4X3:        return 4;
 793                 case TYPE_DOUBLE_MAT4:          return 4;
 794                 default:
 795                         DE_ASSERT(false);
 796                         return 0;
 797         }
 798 }
 799
 800 int     getDataTypeNumLocations (DataType dataType)
 801 {
 802         if (isDataTypeScalarOrVector(dataType))
 803                 return 1;
 804         else if (isDataTypeMatrix(dataType))
 805                 return getDataTypeMatrixNumColumns(dataType);
 806
 807         DE_FATAL("Illegal datatype.");
 808         return 0;
 809 }
 810
 811 int     getDataTypeNumComponents (DataType dataType)
 812 {
 813         if (isDataTypeScalarOrVector(dataType))
 814                 return getDataTypeScalarSize(dataType);
 815         else if (isDataTypeMatrix(dataType))
 816                 return getDataTypeMatrixNumRows(dataType);
 817
 818         DE_FATAL("Illegal datatype.");
 819         return 0;
 820 }
 821
 822 DataType getDataTypeFromGLType (deUint32 glType)
 823 {
 824         switch (glType)
 825         {
 826                 case GL_FLOAT:                                                                          return TYPE_FLOAT;
 827                 case GL_FLOAT_VEC2:                                                                     return TYPE_FLOAT_VEC2;
 828                 case GL_FLOAT_VEC3:                                                                     return TYPE_FLOAT_VEC3;
 829                 case GL_FLOAT_VEC4:                                                                     return TYPE_FLOAT_VEC4;
 830
 831                 case GL_FLOAT_MAT2:                                                                     return TYPE_FLOAT_MAT2;
 832                 case GL_FLOAT_MAT2x3:                                                           return TYPE_FLOAT_MAT2X3;
 833                 case GL_FLOAT_MAT2x4:                                                           return TYPE_FLOAT_MAT2X4;
 834
 835                 case GL_FLOAT_MAT3x2:                                                           return TYPE_FLOAT_MAT3X2;
 836                 case GL_FLOAT_MAT3:                                                                     return TYPE_FLOAT_MAT3;
 837                 case GL_FLOAT_MAT3x4:                                                           return TYPE_FLOAT_MAT3X4;
 838
 839                 case GL_FLOAT_MAT4x2:                                                           return TYPE_FLOAT_MAT4X2;
 840                 case GL_FLOAT_MAT4x3:                                                           return TYPE_FLOAT_MAT4X3;
 841                 case GL_FLOAT_MAT4:                                                                     return TYPE_FLOAT_MAT4;
 842
 843                 case GL_DOUBLE:                                                                         return TYPE_DOUBLE;
 844                 case GL_DOUBLE_VEC2:                                                            return TYPE_DOUBLE_VEC2;
 845                 case GL_DOUBLE_VEC3:                                                            return TYPE_DOUBLE_VEC3;
 846                 case GL_DOUBLE_VEC4:                                                            return TYPE_DOUBLE_VEC4;
 847
 848                 case GL_DOUBLE_MAT2:                                                            return TYPE_DOUBLE_MAT2;
 849                 case GL_DOUBLE_MAT2x3:                                                          return TYPE_DOUBLE_MAT2X3;
 850                 case GL_DOUBLE_MAT2x4:                                                          return TYPE_DOUBLE_MAT2X4;
 851
 852                 case GL_DOUBLE_MAT3x2:                                                          return TYPE_DOUBLE_MAT3X2;
 853                 case GL_DOUBLE_MAT3:                                                            return TYPE_DOUBLE_MAT3;
 854                 case GL_DOUBLE_MAT3x4:                                                          return TYPE_DOUBLE_MAT3X4;
 855
 856                 case GL_DOUBLE_MAT4x2:                                                          return TYPE_DOUBLE_MAT4X2;
 857                 case GL_DOUBLE_MAT4x3:                                                          return TYPE_DOUBLE_MAT4X3;
 858                 case GL_DOUBLE_MAT4:                                                            return TYPE_DOUBLE_MAT4;
 859
 860                 case GL_INT:                                                                            return TYPE_INT;
 861                 case GL_INT_VEC2:                                                                       return TYPE_INT_VEC2;
 862                 case GL_INT_VEC3:                                                                       return TYPE_INT_VEC3;
 863                 case GL_INT_VEC4:                                                                       return TYPE_INT_VEC4;
 864
 865                 case GL_UNSIGNED_INT:                                                           return TYPE_UINT;
 866                 case GL_UNSIGNED_INT_VEC2:                                                      return TYPE_UINT_VEC2;
 867                 case GL_UNSIGNED_INT_VEC3:                                                      return TYPE_UINT_VEC3;
 868                 case GL_UNSIGNED_INT_VEC4:                                                      return TYPE_UINT_VEC4;
 869
 870                 case GL_BOOL:                                                                           return TYPE_BOOL;
 871                 case GL_BOOL_VEC2:                                                                      return TYPE_BOOL_VEC2;
 872                 case GL_BOOL_VEC3:                                                                      return TYPE_BOOL_VEC3;
 873                 case GL_BOOL_VEC4:                                                                      return TYPE_BOOL_VEC4;
 874
 875                 case GL_SAMPLER_1D:                                                                     return TYPE_SAMPLER_1D;
 876                 case GL_SAMPLER_2D:                                                                     return TYPE_SAMPLER_2D;
 877                 case GL_SAMPLER_CUBE:                                                           return TYPE_SAMPLER_CUBE;
 878                 case GL_SAMPLER_1D_ARRAY:                                                       return TYPE_SAMPLER_1D_ARRAY;
 879                 case GL_SAMPLER_2D_ARRAY:                                                       return TYPE_SAMPLER_2D_ARRAY;
 880                 case GL_SAMPLER_3D:                                                                     return TYPE_SAMPLER_3D;
 881                 case GL_SAMPLER_CUBE_MAP_ARRAY:                                         return TYPE_SAMPLER_CUBE_ARRAY;
 882
 883                 case GL_SAMPLER_1D_SHADOW:                                                      return TYPE_SAMPLER_1D_SHADOW;
 884                 case GL_SAMPLER_2D_SHADOW:                                                      return TYPE_SAMPLER_2D_SHADOW;
 885                 case GL_SAMPLER_CUBE_SHADOW:                                            return TYPE_SAMPLER_CUBE_SHADOW;
 886                 case GL_SAMPLER_1D_ARRAY_SHADOW:                                        return TYPE_SAMPLER_1D_ARRAY_SHADOW;
 887                 case GL_SAMPLER_2D_ARRAY_SHADOW:                                        return TYPE_SAMPLER_2D_ARRAY_SHADOW;
 888                 case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:                          return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
 889
 890                 case GL_INT_SAMPLER_1D:                                                         return TYPE_INT_SAMPLER_1D;
 891                 case GL_INT_SAMPLER_2D:                                                         return TYPE_INT_SAMPLER_2D;
 892                 case GL_INT_SAMPLER_CUBE:                                                       return TYPE_INT_SAMPLER_CUBE;
 893                 case GL_INT_SAMPLER_1D_ARRAY:                                           return TYPE_INT_SAMPLER_1D_ARRAY;
 894                 case GL_INT_SAMPLER_2D_ARRAY:                                           return TYPE_INT_SAMPLER_2D_ARRAY;
 895                 case GL_INT_SAMPLER_3D:                                                         return TYPE_INT_SAMPLER_3D;
 896                 case GL_INT_SAMPLER_CUBE_MAP_ARRAY:                                     return TYPE_INT_SAMPLER_CUBE_ARRAY;
 897
 898                 case GL_UNSIGNED_INT_SAMPLER_1D:                                        return TYPE_UINT_SAMPLER_1D;
 899                 case GL_UNSIGNED_INT_SAMPLER_2D:                                        return TYPE_UINT_SAMPLER_2D;
 900                 case GL_UNSIGNED_INT_SAMPLER_CUBE:                                      return TYPE_UINT_SAMPLER_CUBE;
 901                 case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:                          return TYPE_UINT_SAMPLER_1D_ARRAY;
 902                 case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:                          return TYPE_UINT_SAMPLER_2D_ARRAY;
 903                 case GL_UNSIGNED_INT_SAMPLER_3D:                                        return TYPE_UINT_SAMPLER_3D;
 904                 case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:            return TYPE_UINT_SAMPLER_CUBE_ARRAY;
 905
 906                 case GL_SAMPLER_2D_MULTISAMPLE:                                         return TYPE_SAMPLER_2D_MULTISAMPLE;
 907                 case GL_INT_SAMPLER_2D_MULTISAMPLE:                                     return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
 908                 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:            return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
 909
 910                 case GL_IMAGE_2D:                                                                       return TYPE_IMAGE_2D;
 911                 case GL_IMAGE_CUBE:                                                                     return TYPE_IMAGE_CUBE;
 912                 case GL_IMAGE_2D_ARRAY:                                                         return TYPE_IMAGE_2D_ARRAY;
 913                 case GL_IMAGE_3D:                                                                       return TYPE_IMAGE_3D;
 914                 case GL_INT_IMAGE_2D:                                                           return TYPE_INT_IMAGE_2D;
 915                 case GL_INT_IMAGE_CUBE:                                                         return TYPE_INT_IMAGE_CUBE;
 916                 case GL_INT_IMAGE_2D_ARRAY:                                                     return TYPE_INT_IMAGE_2D_ARRAY;
 917                 case GL_INT_IMAGE_3D:                                                           return TYPE_INT_IMAGE_3D;
 918                 case GL_UNSIGNED_INT_IMAGE_2D:                                          return TYPE_UINT_IMAGE_2D;
 919                 case GL_UNSIGNED_INT_IMAGE_CUBE:                                        return TYPE_UINT_IMAGE_CUBE;
 920                 case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:                            return TYPE_UINT_IMAGE_2D_ARRAY;
 921                 case GL_UNSIGNED_INT_IMAGE_3D:                                          return TYPE_UINT_IMAGE_3D;
 922
 923                 case GL_UNSIGNED_INT_ATOMIC_COUNTER:                            return TYPE_UINT_ATOMIC_COUNTER;
 924
 925                 case GL_SAMPLER_BUFFER:                                                         return TYPE_SAMPLER_BUFFER;
 926                 case GL_INT_SAMPLER_BUFFER:                                                     return TYPE_INT_SAMPLER_BUFFER;
 927                 case GL_UNSIGNED_INT_SAMPLER_BUFFER:                            return TYPE_UINT_SAMPLER_BUFFER;
 928
 929                 case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:                           return TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY;
 930                 case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:                       return TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
 931                 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:      return TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY;
 932
 933                 case GL_IMAGE_BUFFER:                                                           return TYPE_IMAGE_BUFFER;
 934                 case GL_INT_IMAGE_BUFFER:                                                       return TYPE_INT_IMAGE_BUFFER;
 935                 case GL_UNSIGNED_INT_IMAGE_BUFFER:                                      return TYPE_UINT_IMAGE_BUFFER;
 936
 937                 default:
 938                         return TYPE_LAST;
 939         }
 940 }
 941
 942 } // glu