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         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         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         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                 "int",
 196                 "ivec2",
 197                 "ivec3",
 198                 "ivec4",
 199                 "uint",
 200                 "uvec2",
 201                 "uvec3",
 202                 "uvec4",
 203                 "bool",
 204                 "bvec2",
 205                 "bvec3",
 206                 "bvec4",
 207                 "sampler1D",
 208                 "sampler2D",
 209                 "samplerCube",
 210                 "sampler2DArray",
 211                 "sampler3D",
 212                 "samplerCubeArray",
 213                 "sampler1DShadow",
 214                 "sampler2DShadow",
 215                 "samplerCubeShadow",
 216                 "sampler2DArrayShadow",
 217                 "samplerCubeArrayShadow",
 218                 "isampler1D",
 219                 "isampler2D",
 220                 "isamplerCube",
 221                 "isampler2DArray",
 222                 "isampler3D",
 223                 "isamplerCubeArray",
 224                 "usampler1D",
 225                 "usampler2D",
 226                 "usamplerCube",
 227                 "usampler2DArray",
 228                 "usampler3D",
 229                 "usamplerCubeArray",
 230                 "sampler2DMS",
 231                 "isampler2DMS",
 232                 "usampler2DMS",
 233                 "image2D",
 234                 "imageCube",
 235                 "image2DArray",
 236                 "image3D",
 237                 "imageCubeArray",
 238                 "iimage2D",
 239                 "iimageCube",
 240                 "iimage2DArray",
 241                 "iimage3D",
 242                 "iimageCubeArray",
 243                 "uimage2D",
 244                 "uimageCube",
 245                 "uimage2DArray",
 246                 "uimage3D",
 247                 "uimageCubeArray",
 248                 "atomic_uint",
 249                 "samplerBuffer",
 250                 "isamplerBuffer",
 251                 "usamplerBuffer",
 252                 "sampler2DMSArray",
 253                 "isampler2DMSArray",
 254                 "usampler2DMSArray",
 255                 "imageBuffer",
 256                 "iimageBuffer",
 257                 "uimageBuffer",
 258         };
 259
 260         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
 261         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
 262         return s_names[(int)dataType];
 263 }
 264
 265 int getDataTypeScalarSize (DataType dataType)
 266 {
 267         const int s_sizes[] =
 268         {
 269                 -1,             // invalid
 270                 1,              // float
 271                 2,              // vec2
 272                 3,              // vec3
 273                 4,              // vec4
 274                 4,              // mat2
 275                 6,              // mat2x3
 276                 8,              // mat2x4
 277                 6,              // mat3x2
 278                 9,              // mat3
 279                 12,             // mat3x4
 280                 8,              // mat4x2
 281                 12,             // mat4x3
 282                 16,             // mat4
 283                 1,              // int
 284                 2,              // ivec2
 285                 3,              // ivec3
 286                 4,              // ivec4
 287                 1,              // uint
 288                 2,              // uvec2
 289                 3,              // uvec3
 290                 4,              // uvec4
 291                 1,              // bool
 292                 2,              // bvec2
 293                 3,              // bvec3
 294                 4,              // bvec4
 295                 1,              // sampler1D
 296                 1,              // sampler2D
 297                 1,              // samplerCube
 298                 1,              // sampler2DArray
 299                 1,              // sampler3D
 300                 1,              // samplerCubeArray
 301                 1,              // sampler1DShadow
 302                 1,              // sampler2DShadow
 303                 1,              // samplerCubeShadow
 304                 1,              // sampler2DArrayShadow
 305                 1,              // samplerCubeArrayShadow
 306                 1,              // isampler1D
 307                 1,              // isampler2D
 308                 1,              // isamplerCube
 309                 1,              // isampler2DArray
 310                 1,              // isampler3D
 311                 1,              // isamplerCubeArray
 312                 1,              // usampler1D
 313                 1,              // usampler2D
 314                 1,              // usamplerCube
 315                 1,              // usampler2DArray
 316                 1,              // usampler3D
 317                 1,              // usamplerCubeArray
 318                 1,              // sampler2DMS
 319                 1,              // isampler2DMS
 320                 1,              // usampler2DMS
 321                 1,              // image2D
 322                 1,              // imageCube
 323                 1,              // image2DArray
 324                 1,              // image3D
 325                 1,              // imageCubeArray
 326                 1,              // iimage2D
 327                 1,              // iimageCube
 328                 1,              // iimage2DArray
 329                 1,              // iimage3D
 330                 1,              // iimageCubeArray
 331                 1,              // uimage2D
 332                 1,              // uimageCube
 333                 1,              // uimage2DArray
 334                 1,              // uimage3D
 335                 1,              // uimageCubeArray
 336                 1,              // atomic_uint
 337                 1,              // samplerBuffer
 338                 1,              // isamplerBuffer
 339                 1,              // usamplerBuffer
 340                 1,              // sampler2DMSArray
 341                 1,              // isampler2DMSArray
 342                 1,              // usampler2DMSArray
 343                 1,              // imageBuffer
 344                 1,              // iimageBuffer
 345                 1,              // uimageBuffer
 346         };
 347
 348         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
 349         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
 350         return s_sizes[(int)dataType];
 351 }
 352
 353 DataType getDataTypeScalarType (DataType dataType)
 354 {
 355         const DataType s_scalarTypes[] =
 356         {
 357                 TYPE_INVALID,                                                   // invalid
 358                 TYPE_FLOAT,                                                             // float
 359                 TYPE_FLOAT,                                                             // vec2
 360                 TYPE_FLOAT,                                                             // vec3
 361                 TYPE_FLOAT,                                                             // vec4
 362                 TYPE_FLOAT,                                                             // mat2
 363                 TYPE_FLOAT,                                                             // mat2x3
 364                 TYPE_FLOAT,                                                             // mat2x4
 365                 TYPE_FLOAT,                                                             // mat3x2
 366                 TYPE_FLOAT,                                                             // mat3
 367                 TYPE_FLOAT,                                                             // mat3x4
 368                 TYPE_FLOAT,                                                             // mat4x2
 369                 TYPE_FLOAT,                                                             // mat4x3
 370                 TYPE_FLOAT,                                                             // mat4
 371                 TYPE_INT,                                                               // int
 372                 TYPE_INT,                                                               // ivec2
 373                 TYPE_INT,                                                               // ivec3
 374                 TYPE_INT,                                                               // ivec4
 375                 TYPE_UINT,                                                              // uint
 376                 TYPE_UINT,                                                              // uvec2
 377                 TYPE_UINT,                                                              // uvec3
 378                 TYPE_UINT,                                                              // uvec4
 379                 TYPE_BOOL,                                                              // bool
 380                 TYPE_BOOL,                                                              // bvec2
 381                 TYPE_BOOL,                                                              // bvec3
 382                 TYPE_BOOL,                                                              // bvec4
 383                 TYPE_SAMPLER_1D,                                                // sampler1D
 384                 TYPE_SAMPLER_2D,                                                // sampler2D
 385                 TYPE_SAMPLER_CUBE,                                              // samplerCube
 386                 TYPE_SAMPLER_2D_ARRAY,                                  // sampler2DArray
 387                 TYPE_SAMPLER_3D,                                                // sampler3D
 388                 TYPE_SAMPLER_CUBE_ARRAY,                                // samplerCubeArray
 389                 TYPE_SAMPLER_1D_SHADOW,                                 // sampler1DShadow
 390                 TYPE_SAMPLER_2D_SHADOW,                                 // sampler2DShadow
 391                 TYPE_SAMPLER_CUBE_SHADOW,                               // samplerCubeShadow
 392                 TYPE_SAMPLER_2D_ARRAY_SHADOW,                   // sampler2DArrayShadow
 393                 TYPE_SAMPLER_CUBE_ARRAY_SHADOW,                 // samplerCubeArrayShadow
 394                 TYPE_INT_SAMPLER_1D,                                    // isampler1D
 395                 TYPE_INT_SAMPLER_2D,                                    // isampler2D
 396                 TYPE_INT_SAMPLER_CUBE,                                  // isamplerCube
 397                 TYPE_INT_SAMPLER_2D_ARRAY,                              // isampler2DArray
 398                 TYPE_INT_SAMPLER_3D,                                    // isampler3D
 399                 TYPE_INT_SAMPLER_CUBE_ARRAY,                    // isamplerCubeArray
 400                 TYPE_UINT_SAMPLER_1D,                                   // usampler1D
 401                 TYPE_UINT_SAMPLER_2D,                                   // usampler2D
 402                 TYPE_UINT_SAMPLER_CUBE,                                 // usamplerCube
 403                 TYPE_UINT_SAMPLER_2D_ARRAY,                             // usampler2DArray
 404                 TYPE_UINT_SAMPLER_3D,                                   // usampler3D
 405                 TYPE_UINT_SAMPLER_CUBE_ARRAY,                   // usamplerCubeArray
 406                 TYPE_SAMPLER_2D_MULTISAMPLE,                    // sampler2DMS
 407                 TYPE_INT_SAMPLER_2D_MULTISAMPLE,                // isampler2DMS
 408                 TYPE_UINT_SAMPLER_2D_MULTISAMPLE,               // usampler2DMS
 409                 TYPE_IMAGE_2D,                                                  // image2D
 410                 TYPE_IMAGE_CUBE,                                                // imageCube
 411                 TYPE_IMAGE_2D_ARRAY,                                    // image2DArray
 412                 TYPE_IMAGE_3D,                                                  // image3D
 413                 TYPE_IMAGE_CUBE_ARRAY,                                  // imageCubeArray
 414                 TYPE_INT_IMAGE_2D,                                              // iimage2D
 415                 TYPE_INT_IMAGE_CUBE,                                    // iimageCube
 416                 TYPE_INT_IMAGE_2D_ARRAY,                                // iimage2DArray
 417                 TYPE_INT_IMAGE_3D,                                              // iimage3D
 418                 TYPE_INT_IMAGE_CUBE_ARRAY,                              // iimageCubeArray
 419                 TYPE_UINT_IMAGE_2D,                                             // uimage2D
 420                 TYPE_UINT_IMAGE_CUBE,                                   // uimageCube
 421                 TYPE_UINT_IMAGE_2D_ARRAY,                               // uimage2DArray
 422                 TYPE_UINT_IMAGE_3D,                                             // uimage3D
 423                 TYPE_UINT_IMAGE_CUBE_ARRAY,                             // uimageCubeArray
 424                 TYPE_UINT_ATOMIC_COUNTER,                               // atomic_uint
 425                 TYPE_SAMPLER_BUFFER,                                    // samplerBuffer
 426                 TYPE_INT_SAMPLER_BUFFER,                                // isamplerBuffer
 427                 TYPE_UINT_SAMPLER_BUFFER,                               // usamplerBuffer
 428                 TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,              // sampler2DMSArray
 429                 TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,  // isampler2DMSArray
 430                 TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, // usampler2DMSArray
 431                 TYPE_IMAGE_BUFFER,                                              // imageBuffer
 432                 TYPE_INT_IMAGE_BUFFER,                                  // iimageBuffer
 433                 TYPE_UINT_IMAGE_BUFFER,                                 // uimageBuffer
 434         };
 435
 436         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
 437         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
 438         return s_scalarTypes[(int)dataType];
 439 }
 440
 441 DataType getDataTypeFloatScalars (DataType dataType)
 442 {
 443         const DataType s_floatTypes[] =
 444         {
 445                 TYPE_INVALID,           // invalid
 446                 TYPE_FLOAT,                     // float
 447                 TYPE_FLOAT_VEC2,        // vec2
 448                 TYPE_FLOAT_VEC3,        // vec3
 449                 TYPE_FLOAT_VEC4,        // vec4
 450                 TYPE_FLOAT_MAT2,        // mat2
 451                 TYPE_FLOAT_MAT2X3,      // mat2x3
 452                 TYPE_FLOAT_MAT2X4,      // mat2x4
 453                 TYPE_FLOAT_MAT3X2,      // mat3x2
 454                 TYPE_FLOAT_MAT3,        // mat3
 455                 TYPE_FLOAT_MAT3X4,      // mat3x4
 456                 TYPE_FLOAT_MAT4X2,      // mat4x2
 457                 TYPE_FLOAT_MAT4X3,      // mat4x3
 458                 TYPE_FLOAT_MAT4,        // mat4
 459                 TYPE_FLOAT,                     // int
 460                 TYPE_FLOAT_VEC2,        // ivec2
 461                 TYPE_FLOAT_VEC3,        // ivec3
 462                 TYPE_FLOAT_VEC4,        // ivec4
 463                 TYPE_FLOAT,                     // uint
 464                 TYPE_FLOAT_VEC2,        // uvec2
 465                 TYPE_FLOAT_VEC3,        // uvec3
 466                 TYPE_FLOAT_VEC4,        // uvec4
 467                 TYPE_FLOAT,                     // bool
 468                 TYPE_FLOAT_VEC2,        // bvec2
 469                 TYPE_FLOAT_VEC3,        // bvec3
 470                 TYPE_FLOAT_VEC4,        // bvec4
 471                 TYPE_INVALID,           // sampler1D
 472                 TYPE_INVALID,           // sampler2D
 473                 TYPE_INVALID,           // samplerCube
 474                 TYPE_INVALID,           // sampler2DArray
 475                 TYPE_INVALID,           // sampler3D
 476                 TYPE_INVALID,           // samplerCubeArray
 477                 TYPE_INVALID,           // sampler1DShadow
 478                 TYPE_INVALID,           // sampler2DShadow
 479                 TYPE_INVALID,           // samplerCubeShadow
 480                 TYPE_INVALID,           // sampler2DArrayShadow
 481                 TYPE_INVALID,           // samplerCubeArrayShadow
 482                 TYPE_INVALID,           // isampler1D
 483                 TYPE_INVALID,           // isampler2D
 484                 TYPE_INVALID,           // isamplerCube
 485                 TYPE_INVALID,           // isampler2DArray
 486                 TYPE_INVALID,           // isampler3D
 487                 TYPE_INVALID,           // isamplerCubeArray
 488                 TYPE_INVALID,           // usampler1D
 489                 TYPE_INVALID,           // usampler2D
 490                 TYPE_INVALID,           // usamplerCube
 491                 TYPE_INVALID,           // usampler2DArray
 492                 TYPE_INVALID,           // usampler3D
 493                 TYPE_INVALID,           // usamplerCubeArray
 494                 TYPE_INVALID,           // sampler2DMS
 495                 TYPE_INVALID,           // isampler2DMS
 496                 TYPE_INVALID,           // usampler2DMS
 497                 TYPE_INVALID,           // image2D
 498                 TYPE_INVALID,           // imageCube
 499                 TYPE_INVALID,           // image2DArray
 500                 TYPE_INVALID,           // image3D
 501                 TYPE_INVALID,           // imageCubeArray
 502                 TYPE_INVALID,           // iimage2D
 503                 TYPE_INVALID,           // iimageCube
 504                 TYPE_INVALID,           // iimage2DArray
 505                 TYPE_INVALID,           // iimage3D
 506                 TYPE_INVALID,           // iimageCubeArray
 507                 TYPE_INVALID,           // uimage2D
 508                 TYPE_INVALID,           // uimageCube
 509                 TYPE_INVALID,           // uimage2DArray
 510                 TYPE_INVALID,           // uimage3D
 511                 TYPE_INVALID,           // uimageCubeArray
 512                 TYPE_INVALID,           // atomic_uint
 513                 TYPE_INVALID,           // samplerBuffer
 514                 TYPE_INVALID,           // isamplerBuffer
 515                 TYPE_INVALID,           // usamplerBuffer
 516                 TYPE_INVALID,           // sampler2DMSArray
 517                 TYPE_INVALID,           // isampler2DMSArray
 518                 TYPE_INVALID,           // usampler2DMSArray
 519                 TYPE_INVALID,           // imageBuffer
 520                 TYPE_INVALID,           // iimageBuffer
 521                 TYPE_INVALID,           // uimageBuffer
 522         };
 523
 524         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
 525         DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
 526         return s_floatTypes[(int)dataType];
 527 }
 528
 529 DataType getDataTypeVector (DataType scalarType, int size)
 530 {
 531         DE_ASSERT(deInRange32(size, 1, 4));
 532         switch (scalarType)
 533         {
 534                 case TYPE_FLOAT:
 535                 case TYPE_INT:
 536                 case TYPE_UINT:
 537                 case TYPE_BOOL:
 538                         return (DataType)((int)scalarType + size - 1);
 539                 default:
 540                         return TYPE_INVALID;
 541         }
 542 }
 543
 544 DataType getDataTypeFloatVec (int vecSize)
 545 {
 546         return getDataTypeVector(TYPE_FLOAT, vecSize);
 547 }
 548
 549 DataType getDataTypeIntVec (int vecSize)
 550 {
 551         return getDataTypeVector(TYPE_INT, vecSize);
 552 }
 553
 554 DataType getDataTypeUintVec (int vecSize)
 555 {
 556         return getDataTypeVector(TYPE_UINT, vecSize);
 557 }
 558
 559 DataType getDataTypeBoolVec (int vecSize)
 560 {
 561         return getDataTypeVector(TYPE_BOOL, vecSize);
 562 }
 563
 564 DataType getDataTypeMatrix (int numCols, int numRows)
 565 {
 566         DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
 567         return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols-2)*3 + (numRows-2));
 568 }
 569
 570 int getDataTypeMatrixNumRows (DataType dataType)
 571 {
 572         switch (dataType)
 573         {
 574                 case TYPE_FLOAT_MAT2:   return 2;
 575                 case TYPE_FLOAT_MAT2X3: return 3;
 576                 case TYPE_FLOAT_MAT2X4: return 4;
 577                 case TYPE_FLOAT_MAT3X2: return 2;
 578                 case TYPE_FLOAT_MAT3:   return 3;
 579                 case TYPE_FLOAT_MAT3X4: return 4;
 580                 case TYPE_FLOAT_MAT4X2: return 2;
 581                 case TYPE_FLOAT_MAT4X3: return 3;
 582                 case TYPE_FLOAT_MAT4:   return 4;
 583                 default:
 584                         DE_ASSERT(false);
 585                         return 0;
 586         }
 587 }
 588
 589 int getDataTypeMatrixNumColumns (DataType dataType)
 590 {
 591         switch (dataType)
 592         {
 593                 case TYPE_FLOAT_MAT2:   return 2;
 594                 case TYPE_FLOAT_MAT2X3: return 2;
 595                 case TYPE_FLOAT_MAT2X4: return 2;
 596                 case TYPE_FLOAT_MAT3X2: return 3;
 597                 case TYPE_FLOAT_MAT3:   return 3;
 598                 case TYPE_FLOAT_MAT3X4: return 3;
 599                 case TYPE_FLOAT_MAT4X2: return 4;
 600                 case TYPE_FLOAT_MAT4X3: return 4;
 601                 case TYPE_FLOAT_MAT4:   return 4;
 602                 default:
 603                         DE_ASSERT(false);
 604                         return 0;
 605         }
 606 }
 607
 608 int     getDataTypeNumLocations (DataType dataType)
 609 {
 610         if (isDataTypeScalarOrVector(dataType))
 611                 return 1;
 612         else if (isDataTypeMatrix(dataType))
 613                 return getDataTypeMatrixNumColumns(dataType);
 614
 615         DE_FATAL("Illegal datatype.");
 616         return 0;
 617 }
 618
 619 int     getDataTypeNumComponents (DataType dataType)
 620 {
 621         if (isDataTypeScalarOrVector(dataType))
 622                 return getDataTypeScalarSize(dataType);
 623         else if (isDataTypeMatrix(dataType))
 624                 return getDataTypeMatrixNumRows(dataType);
 625
 626         DE_FATAL("Illegal datatype.");
 627         return 0;
 628 }
 629
 630 DataType getDataTypeFromGLType (deUint32 glType)
 631 {
 632         switch (glType)
 633         {
 634                 case GL_FLOAT:                                                                          return TYPE_FLOAT;
 635                 case GL_FLOAT_VEC2:                                                                     return TYPE_FLOAT_VEC2;
 636                 case GL_FLOAT_VEC3:                                                                     return TYPE_FLOAT_VEC3;
 637                 case GL_FLOAT_VEC4:                                                                     return TYPE_FLOAT_VEC4;
 638
 639                 case GL_FLOAT_MAT2:                                                                     return TYPE_FLOAT_MAT2;
 640                 case GL_FLOAT_MAT2x3:                                                           return TYPE_FLOAT_MAT2X3;
 641                 case GL_FLOAT_MAT2x4:                                                           return TYPE_FLOAT_MAT2X4;
 642
 643                 case GL_FLOAT_MAT3x2:                                                           return TYPE_FLOAT_MAT3X2;
 644                 case GL_FLOAT_MAT3:                                                                     return TYPE_FLOAT_MAT3;
 645                 case GL_FLOAT_MAT3x4:                                                           return TYPE_FLOAT_MAT3X4;
 646
 647                 case GL_FLOAT_MAT4x2:                                                           return TYPE_FLOAT_MAT4X2;
 648                 case GL_FLOAT_MAT4x3:                                                           return TYPE_FLOAT_MAT4X3;
 649                 case GL_FLOAT_MAT4:                                                                     return TYPE_FLOAT_MAT4;
 650
 651                 case GL_INT:                                                                            return TYPE_INT;
 652                 case GL_INT_VEC2:                                                                       return TYPE_INT_VEC2;
 653                 case GL_INT_VEC3:                                                                       return TYPE_INT_VEC3;
 654                 case GL_INT_VEC4:                                                                       return TYPE_INT_VEC4;
 655
 656                 case GL_UNSIGNED_INT:                                                           return TYPE_UINT;
 657                 case GL_UNSIGNED_INT_VEC2:                                                      return TYPE_UINT_VEC2;
 658                 case GL_UNSIGNED_INT_VEC3:                                                      return TYPE_UINT_VEC3;
 659                 case GL_UNSIGNED_INT_VEC4:                                                      return TYPE_UINT_VEC4;
 660
 661                 case GL_BOOL:                                                                           return TYPE_BOOL;
 662                 case GL_BOOL_VEC2:                                                                      return TYPE_BOOL_VEC2;
 663                 case GL_BOOL_VEC3:                                                                      return TYPE_BOOL_VEC3;
 664                 case GL_BOOL_VEC4:                                                                      return TYPE_BOOL_VEC4;
 665
 666                 case GL_SAMPLER_1D:                                                                     return TYPE_SAMPLER_1D;
 667                 case GL_SAMPLER_2D:                                                                     return TYPE_SAMPLER_2D;
 668                 case GL_SAMPLER_CUBE:                                                           return TYPE_SAMPLER_CUBE;
 669                 case GL_SAMPLER_2D_ARRAY:                                                       return TYPE_SAMPLER_2D_ARRAY;
 670                 case GL_SAMPLER_3D:                                                                     return TYPE_SAMPLER_3D;
 671                 case GL_SAMPLER_CUBE_MAP_ARRAY:                                         return TYPE_SAMPLER_CUBE_ARRAY;
 672
 673                 case GL_SAMPLER_1D_SHADOW:                                                      return TYPE_SAMPLER_1D_SHADOW;
 674                 case GL_SAMPLER_2D_SHADOW:                                                      return TYPE_SAMPLER_2D_SHADOW;
 675                 case GL_SAMPLER_CUBE_SHADOW:                                            return TYPE_SAMPLER_CUBE_SHADOW;
 676                 case GL_SAMPLER_2D_ARRAY_SHADOW:                                        return TYPE_SAMPLER_2D_ARRAY_SHADOW;
 677                 case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:                          return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
 678
 679                 case GL_INT_SAMPLER_1D:                                                         return TYPE_INT_SAMPLER_1D;
 680                 case GL_INT_SAMPLER_2D:                                                         return TYPE_INT_SAMPLER_2D;
 681                 case GL_INT_SAMPLER_CUBE:                                                       return TYPE_INT_SAMPLER_CUBE;
 682                 case GL_INT_SAMPLER_2D_ARRAY:                                           return TYPE_INT_SAMPLER_2D_ARRAY;
 683                 case GL_INT_SAMPLER_3D:                                                         return TYPE_INT_SAMPLER_3D;
 684                 case GL_INT_SAMPLER_CUBE_MAP_ARRAY:                                     return TYPE_INT_SAMPLER_CUBE_ARRAY;
 685
 686                 case GL_UNSIGNED_INT_SAMPLER_1D:                                        return TYPE_UINT_SAMPLER_1D;
 687                 case GL_UNSIGNED_INT_SAMPLER_2D:                                        return TYPE_UINT_SAMPLER_2D;
 688                 case GL_UNSIGNED_INT_SAMPLER_CUBE:                                      return TYPE_UINT_SAMPLER_CUBE;
 689                 case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:                          return TYPE_UINT_SAMPLER_2D_ARRAY;
 690                 case GL_UNSIGNED_INT_SAMPLER_3D:                                        return TYPE_UINT_SAMPLER_3D;
 691                 case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:            return TYPE_UINT_SAMPLER_CUBE_ARRAY;
 692
 693                 case GL_SAMPLER_2D_MULTISAMPLE:                                         return TYPE_SAMPLER_2D_MULTISAMPLE;
 694                 case GL_INT_SAMPLER_2D_MULTISAMPLE:                                     return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
 695                 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:            return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
 696
 697                 case GL_IMAGE_2D:                                                                       return TYPE_IMAGE_2D;
 698                 case GL_IMAGE_CUBE:                                                                     return TYPE_IMAGE_CUBE;
 699                 case GL_IMAGE_2D_ARRAY:                                                         return TYPE_IMAGE_2D_ARRAY;
 700                 case GL_IMAGE_3D:                                                                       return TYPE_IMAGE_3D;
 701                 case GL_INT_IMAGE_2D:                                                           return TYPE_INT_IMAGE_2D;
 702                 case GL_INT_IMAGE_CUBE:                                                         return TYPE_INT_IMAGE_CUBE;
 703                 case GL_INT_IMAGE_2D_ARRAY:                                                     return TYPE_INT_IMAGE_2D_ARRAY;
 704                 case GL_INT_IMAGE_3D:                                                           return TYPE_INT_IMAGE_3D;
 705                 case GL_UNSIGNED_INT_IMAGE_2D:                                          return TYPE_UINT_IMAGE_2D;
 706                 case GL_UNSIGNED_INT_IMAGE_CUBE:                                        return TYPE_UINT_IMAGE_CUBE;
 707                 case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:                            return TYPE_UINT_IMAGE_2D_ARRAY;
 708                 case GL_UNSIGNED_INT_IMAGE_3D:                                          return TYPE_UINT_IMAGE_3D;
 709
 710                 case GL_UNSIGNED_INT_ATOMIC_COUNTER:                            return TYPE_UINT_ATOMIC_COUNTER;
 711
 712                 case GL_SAMPLER_BUFFER:                                                         return TYPE_SAMPLER_BUFFER;
 713                 case GL_INT_SAMPLER_BUFFER:                                                     return TYPE_INT_SAMPLER_BUFFER;
 714                 case GL_UNSIGNED_INT_SAMPLER_BUFFER:                            return TYPE_UINT_SAMPLER_BUFFER;
 715
 716                 case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:                           return TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY;
 717                 case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:                       return TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
 718                 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:      return TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY;
 719
 720                 case GL_IMAGE_BUFFER:                                                           return TYPE_IMAGE_BUFFER;
 721                 case GL_INT_IMAGE_BUFFER:                                                       return TYPE_INT_IMAGE_BUFFER;
 722                 case GL_UNSIGNED_INT_IMAGE_BUFFER:                                      return TYPE_UINT_IMAGE_BUFFER;
 723
 724                 default:
 725                         return TYPE_LAST;
 726         }
 727 }
 728
 729 } // glu