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