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                 "sampler2DArray",
 224                 "sampler3D",
 225                 "samplerCubeArray",
 226                 "sampler1DShadow",
 227                 "sampler2DShadow",
 228                 "samplerCubeShadow",
 229                 "sampler2DArrayShadow",
 230                 "samplerCubeArrayShadow",
 231                 "isampler1D",
 232                 "isampler2D",
 233                 "isamplerCube",
 234                 "isampler2DArray",
 235                 "isampler3D",
 236                 "isamplerCubeArray",
 237                 "usampler1D",
 238                 "usampler2D",
 239                 "usamplerCube",
 240                 "usampler2DArray",
 241                 "usampler3D",
 242                 "usamplerCubeArray",
 243                 "sampler2DMS",
 244                 "isampler2DMS",
 245                 "usampler2DMS",
 246                 "image2D",
 247                 "imageCube",
 248                 "image2DArray",
 249                 "image3D",
 250                 "imageCubeArray",
 251                 "iimage2D",
 252                 "iimageCube",
 253                 "iimage2DArray",
 254                 "iimage3D",
 255                 "iimageCubeArray",
 256                 "uimage2D",
 257                 "uimageCube",
 258                 "uimage2DArray",
 259                 "uimage3D",
 260                 "uimageCubeArray",
 261                 "atomic_uint",
 262                 "samplerBuffer",
 263                 "isamplerBuffer",
 264                 "usamplerBuffer",
 265                 "sampler2DMSArray",
 266                 "isampler2DMSArray",
 267                 "usampler2DMSArray",
 268                 "imageBuffer",
 269                 "iimageBuffer",
 270                 "uimageBuffer",
 271         };
 272
 273         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
 274         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
 275         return s_names[(int)dataType];
 276 }
 277
 278 int getDataTypeScalarSize (DataType dataType)
 279 {
 280         static const int s_sizes[] =
 281         {
 282                 -1,             // invalid
 283                 1,              // float
 284                 2,              // vec2
 285                 3,              // vec3
 286                 4,              // vec4
 287                 4,              // mat2
 288                 6,              // mat2x3
 289                 8,              // mat2x4
 290                 6,              // mat3x2
 291                 9,              // mat3
 292                 12,             // mat3x4
 293                 8,              // mat4x2
 294                 12,             // mat4x3
 295                 16,             // mat4
 296                 1,              // double
 297                 2,              // dvec2
 298                 3,              // dvec3
 299                 4,              // dvec4
 300                 4,              // dmat2
 301                 6,              // dmat2x3
 302                 8,              // dmat2x4
 303                 6,              // dmat3x2
 304                 9,              // dmat3
 305                 12,             // dmat3x4
 306                 8,              // dmat4x2
 307                 12,             // dmat4x3
 308                 16,             // dmat4
 309                 1,              // int
 310                 2,              // ivec2
 311                 3,              // ivec3
 312                 4,              // ivec4
 313                 1,              // uint
 314                 2,              // uvec2
 315                 3,              // uvec3
 316                 4,              // uvec4
 317                 1,              // bool
 318                 2,              // bvec2
 319                 3,              // bvec3
 320                 4,              // bvec4
 321                 1,              // sampler1D
 322                 1,              // sampler2D
 323                 1,              // samplerCube
 324                 1,              // sampler2DArray
 325                 1,              // sampler3D
 326                 1,              // samplerCubeArray
 327                 1,              // sampler1DShadow
 328                 1,              // sampler2DShadow
 329                 1,              // samplerCubeShadow
 330                 1,              // sampler2DArrayShadow
 331                 1,              // samplerCubeArrayShadow
 332                 1,              // isampler1D
 333                 1,              // isampler2D
 334                 1,              // isamplerCube
 335                 1,              // isampler2DArray
 336                 1,              // isampler3D
 337                 1,              // isamplerCubeArray
 338                 1,              // usampler1D
 339                 1,              // usampler2D
 340                 1,              // usamplerCube
 341                 1,              // usampler2DArray
 342                 1,              // usampler3D
 343                 1,              // usamplerCubeArray
 344                 1,              // sampler2DMS
 345                 1,              // isampler2DMS
 346                 1,              // usampler2DMS
 347                 1,              // image2D
 348                 1,              // imageCube
 349                 1,              // image2DArray
 350                 1,              // image3D
 351                 1,              // imageCubeArray
 352                 1,              // iimage2D
 353                 1,              // iimageCube
 354                 1,              // iimage2DArray
 355                 1,              // iimage3D
 356                 1,              // iimageCubeArray
 357                 1,              // uimage2D
 358                 1,              // uimageCube
 359                 1,              // uimage2DArray
 360                 1,              // uimage3D
 361                 1,              // uimageCubeArray
 362                 1,              // atomic_uint
 363                 1,              // samplerBuffer
 364                 1,              // isamplerBuffer
 365                 1,              // usamplerBuffer
 366                 1,              // sampler2DMSArray
 367                 1,              // isampler2DMSArray
 368                 1,              // usampler2DMSArray
 369                 1,              // imageBuffer
 370                 1,              // iimageBuffer
 371                 1,              // uimageBuffer
 372         };
 373
 374         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
 375         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
 376         return s_sizes[(int)dataType];
 377 }
 378
 379 DataType getDataTypeScalarType (DataType dataType)
 380 {
 381         static const DataType s_scalarTypes[] =
 382         {
 383                 TYPE_INVALID,                                                   // invalid
 384                 TYPE_FLOAT,                                                             // float
 385                 TYPE_FLOAT,                                                             // vec2
 386                 TYPE_FLOAT,                                                             // vec3
 387                 TYPE_FLOAT,                                                             // vec4
 388                 TYPE_FLOAT,                                                             // mat2
 389                 TYPE_FLOAT,                                                             // mat2x3
 390                 TYPE_FLOAT,                                                             // mat2x4
 391                 TYPE_FLOAT,                                                             // mat3x2
 392                 TYPE_FLOAT,                                                             // mat3
 393                 TYPE_FLOAT,                                                             // mat3x4
 394                 TYPE_FLOAT,                                                             // mat4x2
 395                 TYPE_FLOAT,                                                             // mat4x3
 396                 TYPE_FLOAT,                                                             // mat4
 397                 TYPE_DOUBLE,                                                    // double
 398                 TYPE_DOUBLE,                                                    // dvec2
 399                 TYPE_DOUBLE,                                                    // dvec3
 400                 TYPE_DOUBLE,                                                    // dvec4
 401                 TYPE_DOUBLE,                                                    // dmat2
 402                 TYPE_DOUBLE,                                                    // dmat2x3
 403                 TYPE_DOUBLE,                                                    // dmat2x4
 404                 TYPE_DOUBLE,                                                    // dmat3x2
 405                 TYPE_DOUBLE,                                                    // dmat3
 406                 TYPE_DOUBLE,                                                    // dmat3x4
 407                 TYPE_DOUBLE,                                                    // dmat4x2
 408                 TYPE_DOUBLE,                                                    // dmat4x3
 409                 TYPE_DOUBLE,                                                    // dmat4
 410                 TYPE_INT,                                                               // int
 411                 TYPE_INT,                                                               // ivec2
 412                 TYPE_INT,                                                               // ivec3
 413                 TYPE_INT,                                                               // ivec4
 414                 TYPE_UINT,                                                              // uint
 415                 TYPE_UINT,                                                              // uvec2
 416                 TYPE_UINT,                                                              // uvec3
 417                 TYPE_UINT,                                                              // uvec4
 418                 TYPE_BOOL,                                                              // bool
 419                 TYPE_BOOL,                                                              // bvec2
 420                 TYPE_BOOL,                                                              // bvec3
 421                 TYPE_BOOL,                                                              // bvec4
 422                 TYPE_SAMPLER_1D,                                                // sampler1D
 423                 TYPE_SAMPLER_2D,                                                // sampler2D
 424                 TYPE_SAMPLER_CUBE,                                              // samplerCube
 425                 TYPE_SAMPLER_2D_ARRAY,                                  // sampler2DArray
 426                 TYPE_SAMPLER_3D,                                                // sampler3D
 427                 TYPE_SAMPLER_CUBE_ARRAY,                                // samplerCubeArray
 428                 TYPE_SAMPLER_1D_SHADOW,                                 // sampler1DShadow
 429                 TYPE_SAMPLER_2D_SHADOW,                                 // sampler2DShadow
 430                 TYPE_SAMPLER_CUBE_SHADOW,                               // samplerCubeShadow
 431                 TYPE_SAMPLER_2D_ARRAY_SHADOW,                   // sampler2DArrayShadow
 432                 TYPE_SAMPLER_CUBE_ARRAY_SHADOW,                 // samplerCubeArrayShadow
 433                 TYPE_INT_SAMPLER_1D,                                    // isampler1D
 434                 TYPE_INT_SAMPLER_2D,                                    // isampler2D
 435                 TYPE_INT_SAMPLER_CUBE,                                  // isamplerCube
 436                 TYPE_INT_SAMPLER_2D_ARRAY,                              // isampler2DArray
 437                 TYPE_INT_SAMPLER_3D,                                    // isampler3D
 438                 TYPE_INT_SAMPLER_CUBE_ARRAY,                    // isamplerCubeArray
 439                 TYPE_UINT_SAMPLER_1D,                                   // usampler1D
 440                 TYPE_UINT_SAMPLER_2D,                                   // usampler2D
 441                 TYPE_UINT_SAMPLER_CUBE,                                 // usamplerCube
 442                 TYPE_UINT_SAMPLER_2D_ARRAY,                             // usampler2DArray
 443                 TYPE_UINT_SAMPLER_3D,                                   // usampler3D
 444                 TYPE_UINT_SAMPLER_CUBE_ARRAY,                   // usamplerCubeArray
 445                 TYPE_SAMPLER_2D_MULTISAMPLE,                    // sampler2DMS
 446                 TYPE_INT_SAMPLER_2D_MULTISAMPLE,                // isampler2DMS
 447                 TYPE_UINT_SAMPLER_2D_MULTISAMPLE,               // usampler2DMS
 448                 TYPE_IMAGE_2D,                                                  // image2D
 449                 TYPE_IMAGE_CUBE,                                                // imageCube
 450                 TYPE_IMAGE_2D_ARRAY,                                    // image2DArray
 451                 TYPE_IMAGE_3D,                                                  // image3D
 452                 TYPE_IMAGE_CUBE_ARRAY,                                  // imageCubeArray
 453                 TYPE_INT_IMAGE_2D,                                              // iimage2D
 454                 TYPE_INT_IMAGE_CUBE,                                    // iimageCube
 455                 TYPE_INT_IMAGE_2D_ARRAY,                                // iimage2DArray
 456                 TYPE_INT_IMAGE_3D,                                              // iimage3D
 457                 TYPE_INT_IMAGE_CUBE_ARRAY,                              // iimageCubeArray
 458                 TYPE_UINT_IMAGE_2D,                                             // uimage2D
 459                 TYPE_UINT_IMAGE_CUBE,                                   // uimageCube
 460                 TYPE_UINT_IMAGE_2D_ARRAY,                               // uimage2DArray
 461                 TYPE_UINT_IMAGE_3D,                                             // uimage3D
 462                 TYPE_UINT_IMAGE_CUBE_ARRAY,                             // uimageCubeArray
 463                 TYPE_UINT_ATOMIC_COUNTER,                               // atomic_uint
 464                 TYPE_SAMPLER_BUFFER,                                    // samplerBuffer
 465                 TYPE_INT_SAMPLER_BUFFER,                                // isamplerBuffer
 466                 TYPE_UINT_SAMPLER_BUFFER,                               // usamplerBuffer
 467                 TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,              // sampler2DMSArray
 468                 TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,  // isampler2DMSArray
 469                 TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, // usampler2DMSArray
 470                 TYPE_IMAGE_BUFFER,                                              // imageBuffer
 471                 TYPE_INT_IMAGE_BUFFER,                                  // iimageBuffer
 472                 TYPE_UINT_IMAGE_BUFFER,                                 // uimageBuffer
 473         };
 474
 475         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
 476         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
 477         return s_scalarTypes[(int)dataType];
 478 }
 479
 480 DataType getDataTypeFloatScalars (DataType dataType)
 481 {
 482         static const DataType s_floatTypes[] =
 483         {
 484                 TYPE_INVALID,           // invalid
 485                 TYPE_FLOAT,                     // float
 486                 TYPE_FLOAT_VEC2,        // vec2
 487                 TYPE_FLOAT_VEC3,        // vec3
 488                 TYPE_FLOAT_VEC4,        // vec4
 489                 TYPE_FLOAT_MAT2,        // mat2
 490                 TYPE_FLOAT_MAT2X3,      // mat2x3
 491                 TYPE_FLOAT_MAT2X4,      // mat2x4
 492                 TYPE_FLOAT_MAT3X2,      // mat3x2
 493                 TYPE_FLOAT_MAT3,        // mat3
 494                 TYPE_FLOAT_MAT3X4,      // mat3x4
 495                 TYPE_FLOAT_MAT4X2,      // mat4x2
 496                 TYPE_FLOAT_MAT4X3,      // mat4x3
 497                 TYPE_FLOAT_MAT4,        // mat4
 498                 TYPE_FLOAT,                     // double
 499                 TYPE_FLOAT_VEC2,        // dvec2
 500                 TYPE_FLOAT_VEC3,        // dvec3
 501                 TYPE_FLOAT_VEC4,        // dvec4
 502                 TYPE_FLOAT_MAT2,        // dmat2
 503                 TYPE_FLOAT_MAT2X3,      // dmat2x3
 504                 TYPE_FLOAT_MAT2X4,      // dmat2x4
 505                 TYPE_FLOAT_MAT3X2,      // dmat3x2
 506                 TYPE_FLOAT_MAT3,        // dmat3
 507                 TYPE_FLOAT_MAT3X4,      // dmat3x4
 508                 TYPE_FLOAT_MAT4X2,      // dmat4x2
 509                 TYPE_FLOAT_MAT4X3,      // dmat4x3
 510                 TYPE_FLOAT_MAT4,        // dmat4
 511                 TYPE_FLOAT,                     // int
 512                 TYPE_FLOAT_VEC2,        // ivec2
 513                 TYPE_FLOAT_VEC3,        // ivec3
 514                 TYPE_FLOAT_VEC4,        // ivec4
 515                 TYPE_FLOAT,                     // uint
 516                 TYPE_FLOAT_VEC2,        // uvec2
 517                 TYPE_FLOAT_VEC3,        // uvec3
 518                 TYPE_FLOAT_VEC4,        // uvec4
 519                 TYPE_FLOAT,                     // bool
 520                 TYPE_FLOAT_VEC2,        // bvec2
 521                 TYPE_FLOAT_VEC3,        // bvec3
 522                 TYPE_FLOAT_VEC4,        // bvec4
 523                 TYPE_INVALID,           // sampler1D
 524                 TYPE_INVALID,           // sampler2D
 525                 TYPE_INVALID,           // samplerCube
 526                 TYPE_INVALID,           // sampler2DArray
 527                 TYPE_INVALID,           // sampler3D
 528                 TYPE_INVALID,           // samplerCubeArray
 529                 TYPE_INVALID,           // sampler1DShadow
 530                 TYPE_INVALID,           // sampler2DShadow
 531                 TYPE_INVALID,           // samplerCubeShadow
 532                 TYPE_INVALID,           // sampler2DArrayShadow
 533                 TYPE_INVALID,           // samplerCubeArrayShadow
 534                 TYPE_INVALID,           // isampler1D
 535                 TYPE_INVALID,           // isampler2D
 536                 TYPE_INVALID,           // isamplerCube
 537                 TYPE_INVALID,           // isampler2DArray
 538                 TYPE_INVALID,           // isampler3D
 539                 TYPE_INVALID,           // isamplerCubeArray
 540                 TYPE_INVALID,           // usampler1D
 541                 TYPE_INVALID,           // usampler2D
 542                 TYPE_INVALID,           // usamplerCube
 543                 TYPE_INVALID,           // usampler2DArray
 544                 TYPE_INVALID,           // usampler3D
 545                 TYPE_INVALID,           // usamplerCubeArray
 546                 TYPE_INVALID,           // sampler2DMS
 547                 TYPE_INVALID,           // isampler2DMS
 548                 TYPE_INVALID,           // usampler2DMS
 549                 TYPE_INVALID,           // image2D
 550                 TYPE_INVALID,           // imageCube
 551                 TYPE_INVALID,           // image2DArray
 552                 TYPE_INVALID,           // image3D
 553                 TYPE_INVALID,           // imageCubeArray
 554                 TYPE_INVALID,           // iimage2D
 555                 TYPE_INVALID,           // iimageCube
 556                 TYPE_INVALID,           // iimage2DArray
 557                 TYPE_INVALID,           // iimage3D
 558                 TYPE_INVALID,           // iimageCubeArray
 559                 TYPE_INVALID,           // uimage2D
 560                 TYPE_INVALID,           // uimageCube
 561                 TYPE_INVALID,           // uimage2DArray
 562                 TYPE_INVALID,           // uimage3D
 563                 TYPE_INVALID,           // uimageCubeArray
 564                 TYPE_INVALID,           // atomic_uint
 565                 TYPE_INVALID,           // samplerBuffer
 566                 TYPE_INVALID,           // isamplerBuffer
 567                 TYPE_INVALID,           // usamplerBuffer
 568                 TYPE_INVALID,           // sampler2DMSArray
 569                 TYPE_INVALID,           // isampler2DMSArray
 570                 TYPE_INVALID,           // usampler2DMSArray
 571                 TYPE_INVALID,           // imageBuffer
 572                 TYPE_INVALID,           // iimageBuffer
 573                 TYPE_INVALID,           // uimageBuffer
 574         };
 575
 576         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
 577         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
 578         return s_floatTypes[(int)dataType];
 579 }
 580
 581 DataType getDataTypeDoubleScalars (DataType dataType)
 582 {
 583         static const DataType s_doubleTypes[] =
 584         {
 585                 TYPE_INVALID,           // invalid
 586                 TYPE_DOUBLE,            // float
 587                 TYPE_DOUBLE_VEC2,       // vec2
 588                 TYPE_DOUBLE_VEC3,       // vec3
 589                 TYPE_DOUBLE_VEC4,       // vec4
 590                 TYPE_DOUBLE_MAT2,       // mat2
 591                 TYPE_DOUBLE_MAT2X3,     // mat2x3
 592                 TYPE_DOUBLE_MAT2X4,     // mat2x4
 593                 TYPE_DOUBLE_MAT3X2,     // mat3x2
 594                 TYPE_DOUBLE_MAT3,       // mat3
 595                 TYPE_DOUBLE_MAT3X4,     // mat3x4
 596                 TYPE_DOUBLE_MAT4X2,     // mat4x2
 597                 TYPE_DOUBLE_MAT4X3,     // mat4x3
 598                 TYPE_DOUBLE_MAT4,       // mat4
 599                 TYPE_DOUBLE,            // double
 600                 TYPE_DOUBLE_VEC2,       // dvec2
 601                 TYPE_DOUBLE_VEC3,       // dvec3
 602                 TYPE_DOUBLE_VEC4,       // dvec4
 603                 TYPE_DOUBLE_MAT2,       // dmat2
 604                 TYPE_DOUBLE_MAT2X3,     // dmat2x3
 605                 TYPE_DOUBLE_MAT2X4,     // dmat2x4
 606                 TYPE_DOUBLE_MAT3X2,     // dmat3x2
 607                 TYPE_DOUBLE_MAT3,       // dmat3
 608                 TYPE_DOUBLE_MAT3X4,     // dmat3x4
 609                 TYPE_DOUBLE_MAT4X2,     // dmat4x2
 610                 TYPE_DOUBLE_MAT4X3,     // dmat4x3
 611                 TYPE_DOUBLE_MAT4,       // dmat4
 612                 TYPE_DOUBLE,            // int
 613                 TYPE_DOUBLE_VEC2,       // ivec2
 614                 TYPE_DOUBLE_VEC3,       // ivec3
 615                 TYPE_DOUBLE_VEC4,       // ivec4
 616                 TYPE_DOUBLE,            // uint
 617                 TYPE_DOUBLE_VEC2,       // uvec2
 618                 TYPE_DOUBLE_VEC3,       // uvec3
 619                 TYPE_DOUBLE_VEC4,       // uvec4
 620                 TYPE_DOUBLE,            // bool
 621                 TYPE_DOUBLE_VEC2,       // bvec2
 622                 TYPE_DOUBLE_VEC3,       // bvec3
 623                 TYPE_DOUBLE_VEC4,       // bvec4
 624                 TYPE_INVALID,           // sampler1D
 625                 TYPE_INVALID,           // sampler2D
 626                 TYPE_INVALID,           // samplerCube
 627                 TYPE_INVALID,           // sampler2DArray
 628                 TYPE_INVALID,           // sampler3D
 629                 TYPE_INVALID,           // samplerCubeArray
 630                 TYPE_INVALID,           // sampler1DShadow
 631                 TYPE_INVALID,           // sampler2DShadow
 632                 TYPE_INVALID,           // samplerCubeShadow
 633                 TYPE_INVALID,           // sampler2DArrayShadow
 634                 TYPE_INVALID,           // samplerCubeArrayShadow
 635                 TYPE_INVALID,           // isampler1D
 636                 TYPE_INVALID,           // isampler2D
 637                 TYPE_INVALID,           // isamplerCube
 638                 TYPE_INVALID,           // isampler2DArray
 639                 TYPE_INVALID,           // isampler3D
 640                 TYPE_INVALID,           // isamplerCubeArray
 641                 TYPE_INVALID,           // usampler1D
 642                 TYPE_INVALID,           // usampler2D
 643                 TYPE_INVALID,           // usamplerCube
 644                 TYPE_INVALID,           // usampler2DArray
 645                 TYPE_INVALID,           // usampler3D
 646                 TYPE_INVALID,           // usamplerCubeArray
 647                 TYPE_INVALID,           // sampler2DMS
 648                 TYPE_INVALID,           // isampler2DMS
 649                 TYPE_INVALID,           // usampler2DMS
 650                 TYPE_INVALID,           // image2D
 651                 TYPE_INVALID,           // imageCube
 652                 TYPE_INVALID,           // image2DArray
 653                 TYPE_INVALID,           // image3D
 654                 TYPE_INVALID,           // imageCubeArray
 655                 TYPE_INVALID,           // iimage2D
 656                 TYPE_INVALID,           // iimageCube
 657                 TYPE_INVALID,           // iimage2DArray
 658                 TYPE_INVALID,           // iimage3D
 659                 TYPE_INVALID,           // iimageCubeArray
 660                 TYPE_INVALID,           // uimage2D
 661                 TYPE_INVALID,           // uimageCube
 662                 TYPE_INVALID,           // uimage2DArray
 663                 TYPE_INVALID,           // uimage3D
 664                 TYPE_INVALID,           // uimageCubeArray
 665                 TYPE_INVALID,           // atomic_uint
 666                 TYPE_INVALID,           // samplerBuffer
 667                 TYPE_INVALID,           // isamplerBuffer
 668                 TYPE_INVALID,           // usamplerBuffer
 669                 TYPE_INVALID,           // sampler2DMSArray
 670                 TYPE_INVALID,           // isampler2DMSArray
 671                 TYPE_INVALID,           // usampler2DMSArray
 672                 TYPE_INVALID,           // imageBuffer
 673                 TYPE_INVALID,           // iimageBuffer
 674                 TYPE_INVALID,           // uimageBuffer
 675         };
 676
 677         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_doubleTypes) == TYPE_LAST);
 678         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_doubleTypes)));
 679         return s_doubleTypes[(int)dataType];
 680 }
 681
 682 DataType getDataTypeVector (DataType scalarType, int size)
 683 {
 684         DE_ASSERT(deInRange32(size, 1, 4));
 685         switch (scalarType)
 686         {
 687                 case TYPE_FLOAT:
 688                 case TYPE_DOUBLE:
 689                 case TYPE_INT:
 690                 case TYPE_UINT:
 691                 case TYPE_BOOL:
 692                         return (DataType)((int)scalarType + size - 1);
 693                 default:
 694                         return TYPE_INVALID;
 695         }
 696 }
 697
 698 DataType getDataTypeFloatVec (int vecSize)
 699 {
 700         return getDataTypeVector(TYPE_FLOAT, vecSize);
 701 }
 702
 703 DataType getDataTypeIntVec (int vecSize)
 704 {
 705         return getDataTypeVector(TYPE_INT, vecSize);
 706 }
 707
 708 DataType getDataTypeUintVec (int vecSize)
 709 {
 710         return getDataTypeVector(TYPE_UINT, vecSize);
 711 }
 712
 713 DataType getDataTypeBoolVec (int vecSize)
 714 {
 715         return getDataTypeVector(TYPE_BOOL, vecSize);
 716 }
 717
 718 DataType getDataTypeMatrix (int numCols, int numRows)
 719 {
 720         DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
 721         return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols-2)*3 + (numRows-2));
 722 }
 723
 724 int getDataTypeMatrixNumRows (DataType dataType)
 725 {
 726         switch (dataType)
 727         {
 728                 case TYPE_FLOAT_MAT2:           return 2;
 729                 case TYPE_FLOAT_MAT2X3:         return 3;
 730                 case TYPE_FLOAT_MAT2X4:         return 4;
 731                 case TYPE_FLOAT_MAT3X2:         return 2;
 732                 case TYPE_FLOAT_MAT3:           return 3;
 733                 case TYPE_FLOAT_MAT3X4:         return 4;
 734                 case TYPE_FLOAT_MAT4X2:         return 2;
 735                 case TYPE_FLOAT_MAT4X3:         return 3;
 736                 case TYPE_FLOAT_MAT4:           return 4;
 737                 case TYPE_DOUBLE_MAT2:          return 2;
 738                 case TYPE_DOUBLE_MAT2X3:        return 3;
 739                 case TYPE_DOUBLE_MAT2X4:        return 4;
 740                 case TYPE_DOUBLE_MAT3X2:        return 2;
 741                 case TYPE_DOUBLE_MAT3:          return 3;
 742                 case TYPE_DOUBLE_MAT3X4:        return 4;
 743                 case TYPE_DOUBLE_MAT4X2:        return 2;
 744                 case TYPE_DOUBLE_MAT4X3:        return 3;
 745                 case TYPE_DOUBLE_MAT4:          return 4;
 746                 default:
 747                         DE_ASSERT(false);
 748                         return 0;
 749         }
 750 }
 751
 752 int getDataTypeMatrixNumColumns (DataType dataType)
 753 {
 754         switch (dataType)
 755         {
 756                 case TYPE_FLOAT_MAT2:           return 2;
 757                 case TYPE_FLOAT_MAT2X3:         return 2;
 758                 case TYPE_FLOAT_MAT2X4:         return 2;
 759                 case TYPE_FLOAT_MAT3X2:         return 3;
 760                 case TYPE_FLOAT_MAT3:           return 3;
 761                 case TYPE_FLOAT_MAT3X4:         return 3;
 762                 case TYPE_FLOAT_MAT4X2:         return 4;
 763                 case TYPE_FLOAT_MAT4X3:         return 4;
 764                 case TYPE_FLOAT_MAT4:           return 4;
 765                 case TYPE_DOUBLE_MAT2:          return 2;
 766                 case TYPE_DOUBLE_MAT2X3:        return 2;
 767                 case TYPE_DOUBLE_MAT2X4:        return 2;
 768                 case TYPE_DOUBLE_MAT3X2:        return 3;
 769                 case TYPE_DOUBLE_MAT3:          return 3;
 770                 case TYPE_DOUBLE_MAT3X4:        return 3;
 771                 case TYPE_DOUBLE_MAT4X2:        return 4;
 772                 case TYPE_DOUBLE_MAT4X3:        return 4;
 773                 case TYPE_DOUBLE_MAT4:          return 4;
 774                 default:
 775                         DE_ASSERT(false);
 776                         return 0;
 777         }
 778 }
 779
 780 int     getDataTypeNumLocations (DataType dataType)
 781 {
 782         if (isDataTypeScalarOrVector(dataType))
 783                 return 1;
 784         else if (isDataTypeMatrix(dataType))
 785                 return getDataTypeMatrixNumColumns(dataType);
 786
 787         DE_FATAL("Illegal datatype.");
 788         return 0;
 789 }
 790
 791 int     getDataTypeNumComponents (DataType dataType)
 792 {
 793         if (isDataTypeScalarOrVector(dataType))
 794                 return getDataTypeScalarSize(dataType);
 795         else if (isDataTypeMatrix(dataType))
 796                 return getDataTypeMatrixNumRows(dataType);
 797
 798         DE_FATAL("Illegal datatype.");
 799         return 0;
 800 }
 801
 802 DataType getDataTypeFromGLType (deUint32 glType)
 803 {
 804         switch (glType)
 805         {
 806                 case GL_FLOAT:                                                                          return TYPE_FLOAT;
 807                 case GL_FLOAT_VEC2:                                                                     return TYPE_FLOAT_VEC2;
 808                 case GL_FLOAT_VEC3:                                                                     return TYPE_FLOAT_VEC3;
 809                 case GL_FLOAT_VEC4:                                                                     return TYPE_FLOAT_VEC4;
 810
 811                 case GL_FLOAT_MAT2:                                                                     return TYPE_FLOAT_MAT2;
 812                 case GL_FLOAT_MAT2x3:                                                           return TYPE_FLOAT_MAT2X3;
 813                 case GL_FLOAT_MAT2x4:                                                           return TYPE_FLOAT_MAT2X4;
 814
 815                 case GL_FLOAT_MAT3x2:                                                           return TYPE_FLOAT_MAT3X2;
 816                 case GL_FLOAT_MAT3:                                                                     return TYPE_FLOAT_MAT3;
 817                 case GL_FLOAT_MAT3x4:                                                           return TYPE_FLOAT_MAT3X4;
 818
 819                 case GL_FLOAT_MAT4x2:                                                           return TYPE_FLOAT_MAT4X2;
 820                 case GL_FLOAT_MAT4x3:                                                           return TYPE_FLOAT_MAT4X3;
 821                 case GL_FLOAT_MAT4:                                                                     return TYPE_FLOAT_MAT4;
 822
 823                 case GL_DOUBLE:                                                                         return TYPE_DOUBLE;
 824                 case GL_DOUBLE_VEC2:                                                            return TYPE_DOUBLE_VEC2;
 825                 case GL_DOUBLE_VEC3:                                                            return TYPE_DOUBLE_VEC3;
 826                 case GL_DOUBLE_VEC4:                                                            return TYPE_DOUBLE_VEC4;
 827
 828                 case GL_DOUBLE_MAT2:                                                            return TYPE_DOUBLE_MAT2;
 829                 case GL_DOUBLE_MAT2x3:                                                          return TYPE_DOUBLE_MAT2X3;
 830                 case GL_DOUBLE_MAT2x4:                                                          return TYPE_DOUBLE_MAT2X4;
 831
 832                 case GL_DOUBLE_MAT3x2:                                                          return TYPE_DOUBLE_MAT3X2;
 833                 case GL_DOUBLE_MAT3:                                                            return TYPE_DOUBLE_MAT3;
 834                 case GL_DOUBLE_MAT3x4:                                                          return TYPE_DOUBLE_MAT3X4;
 835
 836                 case GL_DOUBLE_MAT4x2:                                                          return TYPE_DOUBLE_MAT4X2;
 837                 case GL_DOUBLE_MAT4x3:                                                          return TYPE_DOUBLE_MAT4X3;
 838                 case GL_DOUBLE_MAT4:                                                            return TYPE_DOUBLE_MAT4;
 839
 840                 case GL_INT:                                                                            return TYPE_INT;
 841                 case GL_INT_VEC2:                                                                       return TYPE_INT_VEC2;
 842                 case GL_INT_VEC3:                                                                       return TYPE_INT_VEC3;
 843                 case GL_INT_VEC4:                                                                       return TYPE_INT_VEC4;
 844
 845                 case GL_UNSIGNED_INT:                                                           return TYPE_UINT;
 846                 case GL_UNSIGNED_INT_VEC2:                                                      return TYPE_UINT_VEC2;
 847                 case GL_UNSIGNED_INT_VEC3:                                                      return TYPE_UINT_VEC3;
 848                 case GL_UNSIGNED_INT_VEC4:                                                      return TYPE_UINT_VEC4;
 849
 850                 case GL_BOOL:                                                                           return TYPE_BOOL;
 851                 case GL_BOOL_VEC2:                                                                      return TYPE_BOOL_VEC2;
 852                 case GL_BOOL_VEC3:                                                                      return TYPE_BOOL_VEC3;
 853                 case GL_BOOL_VEC4:                                                                      return TYPE_BOOL_VEC4;
 854
 855                 case GL_SAMPLER_1D:                                                                     return TYPE_SAMPLER_1D;
 856                 case GL_SAMPLER_2D:                                                                     return TYPE_SAMPLER_2D;
 857                 case GL_SAMPLER_CUBE:                                                           return TYPE_SAMPLER_CUBE;
 858                 case GL_SAMPLER_2D_ARRAY:                                                       return TYPE_SAMPLER_2D_ARRAY;
 859                 case GL_SAMPLER_3D:                                                                     return TYPE_SAMPLER_3D;
 860                 case GL_SAMPLER_CUBE_MAP_ARRAY:                                         return TYPE_SAMPLER_CUBE_ARRAY;
 861
 862                 case GL_SAMPLER_1D_SHADOW:                                                      return TYPE_SAMPLER_1D_SHADOW;
 863                 case GL_SAMPLER_2D_SHADOW:                                                      return TYPE_SAMPLER_2D_SHADOW;
 864                 case GL_SAMPLER_CUBE_SHADOW:                                            return TYPE_SAMPLER_CUBE_SHADOW;
 865                 case GL_SAMPLER_2D_ARRAY_SHADOW:                                        return TYPE_SAMPLER_2D_ARRAY_SHADOW;
 866                 case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:                          return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
 867
 868                 case GL_INT_SAMPLER_1D:                                                         return TYPE_INT_SAMPLER_1D;
 869                 case GL_INT_SAMPLER_2D:                                                         return TYPE_INT_SAMPLER_2D;
 870                 case GL_INT_SAMPLER_CUBE:                                                       return TYPE_INT_SAMPLER_CUBE;
 871                 case GL_INT_SAMPLER_2D_ARRAY:                                           return TYPE_INT_SAMPLER_2D_ARRAY;
 872                 case GL_INT_SAMPLER_3D:                                                         return TYPE_INT_SAMPLER_3D;
 873                 case GL_INT_SAMPLER_CUBE_MAP_ARRAY:                                     return TYPE_INT_SAMPLER_CUBE_ARRAY;
 874
 875                 case GL_UNSIGNED_INT_SAMPLER_1D:                                        return TYPE_UINT_SAMPLER_1D;
 876                 case GL_UNSIGNED_INT_SAMPLER_2D:                                        return TYPE_UINT_SAMPLER_2D;
 877                 case GL_UNSIGNED_INT_SAMPLER_CUBE:                                      return TYPE_UINT_SAMPLER_CUBE;
 878                 case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:                          return TYPE_UINT_SAMPLER_2D_ARRAY;
 879                 case GL_UNSIGNED_INT_SAMPLER_3D:                                        return TYPE_UINT_SAMPLER_3D;
 880                 case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:            return TYPE_UINT_SAMPLER_CUBE_ARRAY;
 881
 882                 case GL_SAMPLER_2D_MULTISAMPLE:                                         return TYPE_SAMPLER_2D_MULTISAMPLE;
 883                 case GL_INT_SAMPLER_2D_MULTISAMPLE:                                     return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
 884                 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:            return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
 885
 886                 case GL_IMAGE_2D:                                                                       return TYPE_IMAGE_2D;
 887                 case GL_IMAGE_CUBE:                                                                     return TYPE_IMAGE_CUBE;
 888                 case GL_IMAGE_2D_ARRAY:                                                         return TYPE_IMAGE_2D_ARRAY;
 889                 case GL_IMAGE_3D:                                                                       return TYPE_IMAGE_3D;
 890                 case GL_INT_IMAGE_2D:                                                           return TYPE_INT_IMAGE_2D;
 891                 case GL_INT_IMAGE_CUBE:                                                         return TYPE_INT_IMAGE_CUBE;
 892                 case GL_INT_IMAGE_2D_ARRAY:                                                     return TYPE_INT_IMAGE_2D_ARRAY;
 893                 case GL_INT_IMAGE_3D:                                                           return TYPE_INT_IMAGE_3D;
 894                 case GL_UNSIGNED_INT_IMAGE_2D:                                          return TYPE_UINT_IMAGE_2D;
 895                 case GL_UNSIGNED_INT_IMAGE_CUBE:                                        return TYPE_UINT_IMAGE_CUBE;
 896                 case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:                            return TYPE_UINT_IMAGE_2D_ARRAY;
 897                 case GL_UNSIGNED_INT_IMAGE_3D:                                          return TYPE_UINT_IMAGE_3D;
 898
 899                 case GL_UNSIGNED_INT_ATOMIC_COUNTER:                            return TYPE_UINT_ATOMIC_COUNTER;
 900
 901                 case GL_SAMPLER_BUFFER:                                                         return TYPE_SAMPLER_BUFFER;
 902                 case GL_INT_SAMPLER_BUFFER:                                                     return TYPE_INT_SAMPLER_BUFFER;
 903                 case GL_UNSIGNED_INT_SAMPLER_BUFFER:                            return TYPE_UINT_SAMPLER_BUFFER;
 904
 905                 case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:                           return TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY;
 906                 case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:                       return TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
 907                 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:      return TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY;
 908
 909                 case GL_IMAGE_BUFFER:                                                           return TYPE_IMAGE_BUFFER;
 910                 case GL_INT_IMAGE_BUFFER:                                                       return TYPE_INT_IMAGE_BUFFER;
 911                 case GL_UNSIGNED_INT_IMAGE_BUFFER:                                      return TYPE_UINT_IMAGE_BUFFER;
 912
 913                 default:
 914                         return TYPE_LAST;
 915         }
 916 }
 917
 918 } // glu