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