tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

gluShaderUtil.js (32324B)

      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 
     21 'use strict';
     22 goog.provide('framework.opengl.gluShaderUtil');
     23 goog.require('framework.delibs.debase.deMath');
     24 
     25 goog.scope(function() {
     26 
     27 var gluShaderUtil = framework.opengl.gluShaderUtil;
     28 var deMath = framework.delibs.debase.deMath;
     29 
     30 /**
     31 * ShadingLanguageVersion
     32 * @enum
     33 */
     34 gluShaderUtil.GLSLVersion = {
     35    V100_ES: 0, //!< GLSL ES 1.0
     36    V300_ES: 1 //!< GLSL ES 3.0
     37 };
     38 
     39 /**
     40 * gluShaderUtil.glslVersionUsesInOutQualifiers
     41 * @param {gluShaderUtil.GLSLVersion} version
     42 * @return {boolean}
     43 */
     44 gluShaderUtil.glslVersionUsesInOutQualifiers = function(version) {
     45    return version == gluShaderUtil.GLSLVersion.V300_ES;
     46 };
     47 
     48 /**
     49 * gluShaderUtil.isGLSLVersionSupported
     50 * @param {WebGL2RenderingContext|WebGLRenderingContextBase} ctx
     51 * @param {gluShaderUtil.GLSLVersion} version
     52 * @return {boolean}
     53 */
     54 gluShaderUtil.isGLSLVersionSupported = function(ctx, version) {
     55    return version <= gluShaderUtil.getGLSLVersion(ctx);
     56 };
     57 
     58 /**
     59 * gluShaderUtil.getGLSLVersion - Returns a gluShaderUtil.GLSLVersion based on a given webgl context.
     60 * @param {WebGL2RenderingContext|WebGLRenderingContextBase} gl
     61 * @return {gluShaderUtil.GLSLVersion}
     62 */
     63 gluShaderUtil.getGLSLVersion = function(gl) {
     64    var glslversion = gl.getParameter(gl.SHADING_LANGUAGE_VERSION);
     65 
     66    // TODO: Versions are not yet well implemented... Firefox returns GLSL ES 1.0 in some cases,
     67    // and Chromium returns GLSL ES 2.0 in some cases. Returning the right version for
     68    // testing.
     69    // return gluShaderUtil.GLSLVersion.V300_ES;
     70 
     71    if (glslversion.indexOf('WebGL GLSL ES 1.0') != -1) return gluShaderUtil.GLSLVersion.V100_ES;
     72    if (glslversion.indexOf('WebGL GLSL ES 3.0') != -1) return gluShaderUtil.GLSLVersion.V300_ES;
     73 
     74    throw new Error('Invalid WebGL version');
     75 };
     76 
     77 /**
     78 * gluShaderUtil.getGLSLVersionDeclaration - Returns a string declaration for the glsl version in a shader.
     79 * @param {gluShaderUtil.GLSLVersion} version
     80 * @return {string}
     81 */
     82 gluShaderUtil.getGLSLVersionDeclaration = function(version) {
     83    /** @type {Array<string>} */ var s_decl =
     84    [
     85        '#version 100',
     86        '#version 300 es'
     87    ];
     88 
     89    if (version > s_decl.length - 1)
     90        throw new Error('Unsupported GLSL version.');
     91 
     92    return s_decl[version];
     93 };
     94 
     95 /**
     96 * gluShaderUtil.getGLSLVersionString - Returns the same thing as
     97 * getGLSLVersionDeclaration() but without the substring '#version'
     98 * @param {gluShaderUtil.GLSLVersion} version
     99 * @return {string}
    100 */
    101 gluShaderUtil.getGLSLVersionString = function(version) {
    102    /** @type {Array<string>} */ var s_decl =
    103    [
    104        '100',
    105        '300 es'
    106    ];
    107 
    108    if (version > s_decl.length - 1)
    109        throw new Error('Unsupported GLSL version.');
    110 
    111    return s_decl[version];
    112 };
    113 
    114 /**
    115 * @enum
    116 */
    117 gluShaderUtil.precision = {
    118    PRECISION_LOWP: 0,
    119    PRECISION_MEDIUMP: 1,
    120    PRECISION_HIGHP: 2
    121 };
    122 
    123 gluShaderUtil.getPrecisionName = function(prec) {
    124    var s_names = [
    125        'lowp',
    126        'mediump',
    127        'highp'
    128    ];
    129 
    130    return s_names[prec];
    131 };
    132 
    133 /**
    134 * The Type constants
    135 * @enum {number}
    136 */
    137 gluShaderUtil.DataType = {
    138    INVALID: 0,
    139 
    140    FLOAT: 1,
    141    FLOAT_VEC2: 2,
    142    FLOAT_VEC3: 3,
    143    FLOAT_VEC4: 4,
    144    FLOAT_MAT2: 5,
    145    FLOAT_MAT2X3: 6,
    146    FLOAT_MAT2X4: 7,
    147    FLOAT_MAT3X2: 8,
    148    FLOAT_MAT3: 9,
    149    FLOAT_MAT3X4: 10,
    150    FLOAT_MAT4X2: 11,
    151    FLOAT_MAT4X3: 12,
    152    FLOAT_MAT4: 13,
    153 
    154    INT: 14,
    155    INT_VEC2: 15,
    156    INT_VEC3: 16,
    157    INT_VEC4: 17,
    158 
    159    UINT: 18,
    160    UINT_VEC2: 19,
    161    UINT_VEC3: 20,
    162    UINT_VEC4: 21,
    163 
    164    BOOL: 22,
    165    BOOL_VEC2: 23,
    166    BOOL_VEC3: 24,
    167    BOOL_VEC4: 25,
    168 
    169    SAMPLER_2D: 26,
    170    SAMPLER_CUBE: 27,
    171    SAMPLER_2D_ARRAY: 28,
    172    SAMPLER_3D: 29,
    173 
    174    SAMPLER_2D_SHADOW: 30,
    175    SAMPLER_CUBE_SHADOW: 31,
    176    SAMPLER_2D_ARRAY_SHADOW: 32,
    177 
    178    INT_SAMPLER_2D: 33,
    179    INT_SAMPLER_CUBE: 34,
    180    INT_SAMPLER_2D_ARRAY: 35,
    181    INT_SAMPLER_3D: 36,
    182 
    183    UINT_SAMPLER_2D: 37,
    184    UINT_SAMPLER_CUBE: 38,
    185    UINT_SAMPLER_2D_ARRAY: 39,
    186    UINT_SAMPLER_3D: 40
    187 };
    188 
    189 /**
    190 * Returns type of float scalars
    191 * @param {gluShaderUtil.DataType} dataType
    192 * @return {string} type of float scalar
    193 */
    194 gluShaderUtil.getDataTypeFloatScalars = function(dataType) {
    195 
    196    switch (dataType) {
    197        case gluShaderUtil.DataType.FLOAT: return 'float';
    198        case gluShaderUtil.DataType.FLOAT_VEC2: return 'vec2';
    199        case gluShaderUtil.DataType.FLOAT_VEC3: return 'vec3';
    200        case gluShaderUtil.DataType.FLOAT_VEC4: return 'vec4';
    201        case gluShaderUtil.DataType.FLOAT_MAT2: return 'mat2';
    202        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 'mat2x3';
    203        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 'mat2x4';
    204        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 'mat3x2';
    205        case gluShaderUtil.DataType.FLOAT_MAT3: return 'mat3';
    206        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 'mat3x4';
    207        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 'mat4x2';
    208        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 'mat4x3';
    209        case gluShaderUtil.DataType.FLOAT_MAT4: return 'mat4';
    210        case gluShaderUtil.DataType.INT: return 'float';
    211        case gluShaderUtil.DataType.INT_VEC2: return 'vec2';
    212        case gluShaderUtil.DataType.INT_VEC3: return 'vec3';
    213        case gluShaderUtil.DataType.INT_VEC4: return 'vec4';
    214        case gluShaderUtil.DataType.UINT: return 'float';
    215        case gluShaderUtil.DataType.UINT_VEC2: return 'vec2';
    216        case gluShaderUtil.DataType.UINT_VEC3: return 'vec3';
    217        case gluShaderUtil.DataType.UINT_VEC4: return 'vec4';
    218        case gluShaderUtil.DataType.BOOL: return 'float';
    219        case gluShaderUtil.DataType.BOOL_VEC2: return 'vec2';
    220        case gluShaderUtil.DataType.BOOL_VEC3: return 'vec3';
    221        case gluShaderUtil.DataType.BOOL_VEC4: return 'vec4';
    222    }
    223    throw Error('Unrecognized dataType ' + dataType);
    224 };
    225 
    226 /**
    227 * gluShaderUtil.getDataTypeVector
    228 * @param {gluShaderUtil.DataType} scalarType
    229 * @param {number} size
    230 * @return {gluShaderUtil.DataType}
    231 */
    232 gluShaderUtil.getDataTypeVector = function(scalarType, size) {
    233    var floats = [gluShaderUtil.DataType.FLOAT,
    234                  gluShaderUtil.DataType.FLOAT_VEC2,
    235                  gluShaderUtil.DataType.FLOAT_VEC3,
    236                  gluShaderUtil.DataType.FLOAT_VEC4];
    237    var ints = [gluShaderUtil.DataType.INT,
    238                  gluShaderUtil.DataType.INT_VEC2,
    239                  gluShaderUtil.DataType.INT_VEC3,
    240                  gluShaderUtil.DataType.INT_VEC4];
    241    var uints = [gluShaderUtil.DataType.UINT,
    242                  gluShaderUtil.DataType.UINT_VEC2,
    243                  gluShaderUtil.DataType.UINT_VEC3,
    244                  gluShaderUtil.DataType.UINT_VEC4];
    245    var bools = [gluShaderUtil.DataType.BOOL,
    246                  gluShaderUtil.DataType.BOOL_VEC2,
    247                  gluShaderUtil.DataType.BOOL_VEC3,
    248                  gluShaderUtil.DataType.BOOL_VEC4];
    249 
    250    switch (scalarType) {
    251        case gluShaderUtil.DataType.FLOAT: return floats[size - 1];
    252        case gluShaderUtil.DataType.INT: return ints[size - 1];
    253        case gluShaderUtil.DataType.UINT: return uints[size - 1];
    254        case gluShaderUtil.DataType.BOOL: return bools[size - 1];
    255        default:
    256            throw new Error('Scalar type is not a vectoe:' + scalarType);
    257    }
    258 };
    259 
    260 /**
    261 * gluShaderUtil.getDataTypeFloatVec
    262 * @param {number} vecSize
    263 * @return {gluShaderUtil.DataType}
    264 */
    265 gluShaderUtil.getDataTypeFloatVec = function(vecSize) {
    266    return gluShaderUtil.getDataTypeVector(gluShaderUtil.DataType.FLOAT, vecSize);
    267 };
    268 
    269 /**
    270 * gluShaderUtil.isDataTypeBoolOrBVec
    271 * @param {gluShaderUtil.DataType} dataType
    272 * @return {boolean}
    273 */
    274 gluShaderUtil.isDataTypeBoolOrBVec = function(dataType) {
    275    return (dataType >= gluShaderUtil.DataType.BOOL) && (dataType <= gluShaderUtil.DataType.BOOL_VEC4);
    276 };
    277 
    278 /**
    279 * Returns type of scalar
    280 * @param {gluShaderUtil.DataType} dataType shader
    281 * @return {string} type of scalar type
    282 */
    283 gluShaderUtil.getDataTypeScalarType = function(dataType) {
    284    switch (dataType) {
    285        case gluShaderUtil.DataType.FLOAT: return 'float';
    286        case gluShaderUtil.DataType.FLOAT_VEC2: return 'float';
    287        case gluShaderUtil.DataType.FLOAT_VEC3: return 'float';
    288        case gluShaderUtil.DataType.FLOAT_VEC4: return 'float';
    289        case gluShaderUtil.DataType.FLOAT_MAT2: return 'float';
    290        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 'float';
    291        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 'float';
    292        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 'float';
    293        case gluShaderUtil.DataType.FLOAT_MAT3: return 'float';
    294        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 'float';
    295        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 'float';
    296        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 'float';
    297        case gluShaderUtil.DataType.FLOAT_MAT4: return 'float';
    298        case gluShaderUtil.DataType.INT: return 'int';
    299        case gluShaderUtil.DataType.INT_VEC2: return 'int';
    300        case gluShaderUtil.DataType.INT_VEC3: return 'int';
    301        case gluShaderUtil.DataType.INT_VEC4: return 'int';
    302        case gluShaderUtil.DataType.UINT: return 'uint';
    303        case gluShaderUtil.DataType.UINT_VEC2: return 'uint';
    304        case gluShaderUtil.DataType.UINT_VEC3: return 'uint';
    305        case gluShaderUtil.DataType.UINT_VEC4: return 'uint';
    306        case gluShaderUtil.DataType.BOOL: return 'bool';
    307        case gluShaderUtil.DataType.BOOL_VEC2: return 'bool';
    308        case gluShaderUtil.DataType.BOOL_VEC3: return 'bool';
    309        case gluShaderUtil.DataType.BOOL_VEC4: return 'bool';
    310        case gluShaderUtil.DataType.SAMPLER_2D: return 'sampler2D';
    311        case gluShaderUtil.DataType.SAMPLER_CUBE: return 'samplerCube';
    312        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY: return 'sampler2DArray';
    313        case gluShaderUtil.DataType.SAMPLER_3D: return 'sampler3D';
    314        case gluShaderUtil.DataType.SAMPLER_2D_SHADOW: return 'sampler2DShadow';
    315        case gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW: return 'samplerCubeShadow';
    316        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW: return 'sampler2DArrayShadow';
    317        case gluShaderUtil.DataType.INT_SAMPLER_2D: return 'isampler2D';
    318        case gluShaderUtil.DataType.INT_SAMPLER_CUBE: return 'isamplerCube';
    319        case gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY: return 'isampler2DArray';
    320        case gluShaderUtil.DataType.INT_SAMPLER_3D: return 'isampler3D';
    321        case gluShaderUtil.DataType.UINT_SAMPLER_2D: return 'usampler2D';
    322        case gluShaderUtil.DataType.UINT_SAMPLER_CUBE: return 'usamplerCube';
    323        case gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY: return 'usampler2DArray';
    324        case gluShaderUtil.DataType.UINT_SAMPLER_3D: return 'usampler3D';
    325    }
    326   throw new Error('Unrecognized datatype:' + dataType);
    327 };
    328 
    329 /**
    330 * Returns type of scalar
    331 * @param {?gluShaderUtil.DataType} dataType shader
    332 * @return {gluShaderUtil.DataType} type of scalar type
    333 */
    334 gluShaderUtil.getDataTypeScalarTypeAsDataType = function(dataType) {
    335    switch (dataType) {
    336        case gluShaderUtil.DataType.FLOAT: return gluShaderUtil.DataType.FLOAT;
    337        case gluShaderUtil.DataType.FLOAT_VEC2: return gluShaderUtil.DataType.FLOAT;
    338        case gluShaderUtil.DataType.FLOAT_VEC3: return gluShaderUtil.DataType.FLOAT;
    339        case gluShaderUtil.DataType.FLOAT_VEC4: return gluShaderUtil.DataType.FLOAT;
    340        case gluShaderUtil.DataType.FLOAT_MAT2: return gluShaderUtil.DataType.FLOAT;
    341        case gluShaderUtil.DataType.FLOAT_MAT2X3: return gluShaderUtil.DataType.FLOAT;
    342        case gluShaderUtil.DataType.FLOAT_MAT2X4: return gluShaderUtil.DataType.FLOAT;
    343        case gluShaderUtil.DataType.FLOAT_MAT3X2: return gluShaderUtil.DataType.FLOAT;
    344        case gluShaderUtil.DataType.FLOAT_MAT3: return gluShaderUtil.DataType.FLOAT;
    345        case gluShaderUtil.DataType.FLOAT_MAT3X4: return gluShaderUtil.DataType.FLOAT;
    346        case gluShaderUtil.DataType.FLOAT_MAT4X2: return gluShaderUtil.DataType.FLOAT;
    347        case gluShaderUtil.DataType.FLOAT_MAT4X3: return gluShaderUtil.DataType.FLOAT;
    348        case gluShaderUtil.DataType.FLOAT_MAT4: return gluShaderUtil.DataType.FLOAT;
    349        case gluShaderUtil.DataType.INT: return gluShaderUtil.DataType.INT;
    350        case gluShaderUtil.DataType.INT_VEC2: return gluShaderUtil.DataType.INT;
    351        case gluShaderUtil.DataType.INT_VEC3: return gluShaderUtil.DataType.INT;
    352        case gluShaderUtil.DataType.INT_VEC4: return gluShaderUtil.DataType.INT;
    353        case gluShaderUtil.DataType.UINT: return gluShaderUtil.DataType.UINT;
    354        case gluShaderUtil.DataType.UINT_VEC2: return gluShaderUtil.DataType.UINT;
    355        case gluShaderUtil.DataType.UINT_VEC3: return gluShaderUtil.DataType.UINT;
    356        case gluShaderUtil.DataType.UINT_VEC4: return gluShaderUtil.DataType.UINT;
    357        case gluShaderUtil.DataType.BOOL: return gluShaderUtil.DataType.BOOL;
    358        case gluShaderUtil.DataType.BOOL_VEC2: return gluShaderUtil.DataType.BOOL;
    359        case gluShaderUtil.DataType.BOOL_VEC3: return gluShaderUtil.DataType.BOOL;
    360        case gluShaderUtil.DataType.BOOL_VEC4: return gluShaderUtil.DataType.BOOL;
    361        case gluShaderUtil.DataType.SAMPLER_2D:
    362        case gluShaderUtil.DataType.SAMPLER_CUBE:
    363        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY:
    364        case gluShaderUtil.DataType.SAMPLER_3D:
    365        case gluShaderUtil.DataType.SAMPLER_2D_SHADOW:
    366        case gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW:
    367        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW:
    368        case gluShaderUtil.DataType.INT_SAMPLER_2D:
    369        case gluShaderUtil.DataType.INT_SAMPLER_CUBE:
    370        case gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY:
    371        case gluShaderUtil.DataType.INT_SAMPLER_3D:
    372        case gluShaderUtil.DataType.UINT_SAMPLER_2D:
    373        case gluShaderUtil.DataType.UINT_SAMPLER_CUBE:
    374        case gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY:
    375        case gluShaderUtil.DataType.UINT_SAMPLER_3D:
    376            return dataType;
    377    }
    378    throw Error('Unrecognized dataType ' + dataType);
    379 };
    380 
    381 /**
    382 * Checks if dataType is integer or vectors of integers
    383 * @param {gluShaderUtil.DataType} dataType shader
    384 * @return {boolean} Is dataType integer or integer vector
    385 */
    386 gluShaderUtil.isDataTypeIntOrIVec = function(dataType) {
    387    /** @type {boolean} */ var retVal = false;
    388    switch (dataType) {
    389        case gluShaderUtil.DataType.INT:
    390        case gluShaderUtil.DataType.INT_VEC2:
    391        case gluShaderUtil.DataType.INT_VEC3:
    392        case gluShaderUtil.DataType.INT_VEC4:
    393            retVal = true;
    394    }
    395 
    396    return retVal;
    397 };
    398 
    399 /**
    400 * Checks if dataType is unsigned integer or vectors of unsigned integers
    401 * @param {gluShaderUtil.DataType} dataType shader
    402 * @return {boolean} Is dataType unsigned integer or unsigned integer vector
    403 */
    404 gluShaderUtil.isDataTypeUintOrUVec = function(dataType) {
    405    /** @type {boolean} */ var retVal = false;
    406    switch (dataType) {
    407        case gluShaderUtil.DataType.UINT:
    408        case gluShaderUtil.DataType.UINT_VEC2:
    409        case gluShaderUtil.DataType.UINT_VEC3:
    410        case gluShaderUtil.DataType.UINT_VEC4:
    411            retVal = true;
    412    }
    413 
    414    return retVal;
    415 };
    416 
    417 /**
    418 * Returns type of scalar size
    419 * @param {gluShaderUtil.DataType} dataType shader
    420 * @return {number} with size of the type of scalar
    421 */
    422 gluShaderUtil.getDataTypeScalarSize = function(dataType) {
    423    switch (dataType) {
    424        case gluShaderUtil.DataType.FLOAT: return 1;
    425        case gluShaderUtil.DataType.FLOAT_VEC2: return 2;
    426        case gluShaderUtil.DataType.FLOAT_VEC3: return 3;
    427        case gluShaderUtil.DataType.FLOAT_VEC4: return 4;
    428        case gluShaderUtil.DataType.FLOAT_MAT2: return 4;
    429        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 6;
    430        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 8;
    431        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 6;
    432        case gluShaderUtil.DataType.FLOAT_MAT3: return 9;
    433        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 12;
    434        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 8;
    435        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 12;
    436        case gluShaderUtil.DataType.FLOAT_MAT4: return 16;
    437        case gluShaderUtil.DataType.INT: return 1;
    438        case gluShaderUtil.DataType.INT_VEC2: return 2;
    439        case gluShaderUtil.DataType.INT_VEC3: return 3;
    440        case gluShaderUtil.DataType.INT_VEC4: return 4;
    441        case gluShaderUtil.DataType.UINT: return 1;
    442        case gluShaderUtil.DataType.UINT_VEC2: return 2;
    443        case gluShaderUtil.DataType.UINT_VEC3: return 3;
    444        case gluShaderUtil.DataType.UINT_VEC4: return 4;
    445        case gluShaderUtil.DataType.BOOL: return 1;
    446        case gluShaderUtil.DataType.BOOL_VEC2: return 2;
    447        case gluShaderUtil.DataType.BOOL_VEC3: return 3;
    448        case gluShaderUtil.DataType.BOOL_VEC4: return 4;
    449        case gluShaderUtil.DataType.SAMPLER_2D: return 1;
    450        case gluShaderUtil.DataType.SAMPLER_CUBE: return 1;
    451        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY: return 1;
    452        case gluShaderUtil.DataType.SAMPLER_3D: return 1;
    453        case gluShaderUtil.DataType.SAMPLER_2D_SHADOW: return 1;
    454        case gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW: return 1;
    455        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW: return 1;
    456        case gluShaderUtil.DataType.INT_SAMPLER_2D: return 1;
    457        case gluShaderUtil.DataType.INT_SAMPLER_CUBE: return 1;
    458        case gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY: return 1;
    459        case gluShaderUtil.DataType.INT_SAMPLER_3D: return 1;
    460        case gluShaderUtil.DataType.UINT_SAMPLER_2D: return 1;
    461        case gluShaderUtil.DataType.UINT_SAMPLER_CUBE: return 1;
    462        case gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY: return 1;
    463        case gluShaderUtil.DataType.UINT_SAMPLER_3D: return 1;
    464    }
    465    throw Error('Unrecognized dataType ' + dataType);
    466 };
    467 
    468 /**
    469 * Checks if dataType is float or vector
    470 * @param {?gluShaderUtil.DataType} dataType shader
    471 * @return {boolean} Is dataType float or vector
    472 */
    473 gluShaderUtil.isDataTypeFloatOrVec = function(dataType) {
    474    switch (dataType) {
    475        case gluShaderUtil.DataType.FLOAT:
    476        case gluShaderUtil.DataType.FLOAT_VEC2:
    477        case gluShaderUtil.DataType.FLOAT_VEC3:
    478        case gluShaderUtil.DataType.FLOAT_VEC4:
    479            return true;
    480    }
    481    return false;
    482 };
    483 
    484 /**
    485 * Checks if dataType is a matrix
    486 * @param {gluShaderUtil.DataType} dataType shader
    487 * @return {boolean} Is dataType matrix or not
    488 */
    489 gluShaderUtil.isDataTypeMatrix = function(dataType) {
    490    switch (dataType) {
    491        case gluShaderUtil.DataType.FLOAT_MAT2:
    492        case gluShaderUtil.DataType.FLOAT_MAT2X3:
    493        case gluShaderUtil.DataType.FLOAT_MAT2X4:
    494        case gluShaderUtil.DataType.FLOAT_MAT3X2:
    495        case gluShaderUtil.DataType.FLOAT_MAT3:
    496        case gluShaderUtil.DataType.FLOAT_MAT3X4:
    497        case gluShaderUtil.DataType.FLOAT_MAT4X2:
    498        case gluShaderUtil.DataType.FLOAT_MAT4X3:
    499        case gluShaderUtil.DataType.FLOAT_MAT4:
    500            return true;
    501    }
    502    return false;
    503 };
    504 
    505 /**
    506 * Checks if dataType is a vector
    507 * @param {gluShaderUtil.DataType} dataType shader
    508 * @return {boolean} Is dataType vector or not
    509 */
    510 gluShaderUtil.isDataTypeScalar = function(dataType) {
    511    switch (dataType) {
    512        case gluShaderUtil.DataType.FLOAT:
    513        case gluShaderUtil.DataType.INT:
    514        case gluShaderUtil.DataType.UINT:
    515        case gluShaderUtil.DataType.BOOL:
    516            return true;
    517    }
    518    return false;
    519 };
    520 
    521 /**
    522 * Checks if dataType is a vector
    523 * @param {gluShaderUtil.DataType} dataType shader
    524 * @return {boolean} Is dataType vector or not
    525 */
    526 gluShaderUtil.isDataTypeVector = function(dataType) {
    527    switch (dataType) {
    528        case gluShaderUtil.DataType.FLOAT_VEC2:
    529        case gluShaderUtil.DataType.FLOAT_VEC3:
    530        case gluShaderUtil.DataType.FLOAT_VEC4:
    531        case gluShaderUtil.DataType.INT_VEC2:
    532        case gluShaderUtil.DataType.INT_VEC3:
    533        case gluShaderUtil.DataType.INT_VEC4:
    534        case gluShaderUtil.DataType.UINT_VEC2:
    535        case gluShaderUtil.DataType.UINT_VEC3:
    536        case gluShaderUtil.DataType.UINT_VEC4:
    537        case gluShaderUtil.DataType.BOOL_VEC2:
    538        case gluShaderUtil.DataType.BOOL_VEC3:
    539        case gluShaderUtil.DataType.BOOL_VEC4:
    540            return true;
    541    }
    542    return false;
    543 };
    544 
    545 /**
    546 * Checks if dataType is a vector or a scalar type
    547 * @param {gluShaderUtil.DataType} dataType shader
    548 * @return {boolean} Is dataType vector or scalar or not
    549 */
    550 gluShaderUtil.isDataTypeScalarOrVector = function(dataType) {
    551    switch (dataType) {
    552        case gluShaderUtil.DataType.FLOAT:
    553        case gluShaderUtil.DataType.FLOAT_VEC2:
    554        case gluShaderUtil.DataType.FLOAT_VEC3:
    555        case gluShaderUtil.DataType.FLOAT_VEC4:
    556        case gluShaderUtil.DataType.INT:
    557        case gluShaderUtil.DataType.INT_VEC2:
    558        case gluShaderUtil.DataType.INT_VEC3:
    559        case gluShaderUtil.DataType.INT_VEC4:
    560        case gluShaderUtil.DataType.UINT:
    561        case gluShaderUtil.DataType.UINT_VEC2:
    562        case gluShaderUtil.DataType.UINT_VEC3:
    563        case gluShaderUtil.DataType.UINT_VEC4:
    564        case gluShaderUtil.DataType.BOOL:
    565        case gluShaderUtil.DataType.BOOL_VEC2:
    566        case gluShaderUtil.DataType.BOOL_VEC3:
    567        case gluShaderUtil.DataType.BOOL_VEC4:
    568            return true;
    569    }
    570    return false;
    571 };
    572 
    573 /**
    574 * Checks if dataType is a sampler
    575 * @param {gluShaderUtil.DataType} dataType shader
    576 * @return {boolean} Is dataType vector or scalar or not
    577 */
    578 gluShaderUtil.isDataTypeSampler = function(dataType) {
    579    return (dataType >= gluShaderUtil.DataType.SAMPLER_2D) && (dataType <= gluShaderUtil.DataType.UINT_SAMPLER_3D);
    580 };
    581 
    582 /**
    583 * Returns a gluShaderUtil.DataType based on given rows and columns
    584 * @param {number} numCols
    585 * @param {number} numRows
    586 * @return {gluShaderUtil.DataType}
    587 */
    588 gluShaderUtil.getDataTypeMatrix = function(numCols, numRows) {
    589    if (!(deMath.deInRange32(numCols, 2, 4) && deMath.deInRange32(numRows, 2, 4)))
    590        throw new Error('Out of bounds: (' + numCols + ',' + numRows + ')');
    591 
    592    var size = numCols.toString() + 'x' + numRows.toString();
    593    var datatypes = {
    594        '2x2': gluShaderUtil.DataType.FLOAT_MAT2,
    595        '2x3': gluShaderUtil.DataType.FLOAT_MAT2X3,
    596        '2x4': gluShaderUtil.DataType.FLOAT_MAT2X4,
    597        '3x2': gluShaderUtil.DataType.FLOAT_MAT3X2,
    598        '3x3': gluShaderUtil.DataType.FLOAT_MAT3,
    599        '3x4': gluShaderUtil.DataType.FLOAT_MAT3X4,
    600        '4x2': gluShaderUtil.DataType.FLOAT_MAT4X2,
    601        '4x3': gluShaderUtil.DataType.FLOAT_MAT4X3,
    602        '4x4': gluShaderUtil.DataType.FLOAT_MAT4
    603    };
    604    return datatypes[size];
    605 };
    606 
    607 /**
    608 * Returns number of rows of a gluShaderUtil.DataType Matrix
    609 * @param {gluShaderUtil.DataType} dataType shader
    610 * @return {number} with number of rows depending on gluShaderUtil.DataType Matrix
    611 */
    612 gluShaderUtil.getDataTypeMatrixNumRows = function(dataType) {
    613    switch (dataType) {
    614        case gluShaderUtil.DataType.FLOAT_MAT2: return 2;
    615        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 3;
    616        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 4;
    617        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 2;
    618        case gluShaderUtil.DataType.FLOAT_MAT3: return 3;
    619        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 4;
    620        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 2;
    621        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 3;
    622        case gluShaderUtil.DataType.FLOAT_MAT4: return 4;
    623    }
    624    throw Error('Unrecognized dataType ' + dataType);
    625 };
    626 
    627 /**
    628 * Returns number of columns of a gluShaderUtil.DataType Matrix
    629 * @param {gluShaderUtil.DataType} dataType shader
    630 * @return {number} with number of columns depending on gluShaderUtil.DataType Matrix
    631 */
    632 gluShaderUtil.getDataTypeMatrixNumColumns = function(dataType) {
    633    switch (dataType) {
    634        case gluShaderUtil.DataType.FLOAT_MAT2: return 2;
    635        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 2;
    636        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 2;
    637        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 3;
    638        case gluShaderUtil.DataType.FLOAT_MAT3: return 3;
    639        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 3;
    640        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 4;
    641        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 4;
    642        case gluShaderUtil.DataType.FLOAT_MAT4: return 4;
    643    }
    644    throw Error('Unrecognized dataType ' + dataType);
    645 };
    646 
    647 /**
    648 * @param {gluShaderUtil.DataType} dataType
    649 * @return {number}
    650 */
    651 gluShaderUtil.getDataTypeNumLocations = function(dataType) {
    652    if (gluShaderUtil.isDataTypeScalarOrVector(dataType))
    653        return 1;
    654    else if (gluShaderUtil.isDataTypeMatrix(dataType))
    655        return gluShaderUtil.getDataTypeMatrixNumColumns(dataType);
    656    throw Error('Unrecognized dataType ' + dataType);
    657 };
    658 
    659 /**
    660 * @param {gluShaderUtil.DataType} dataType
    661 * @return {number}
    662 */
    663 gluShaderUtil.getDataTypeNumComponents = function(dataType) {
    664    if (gluShaderUtil.isDataTypeScalarOrVector(dataType))
    665        return gluShaderUtil.getDataTypeScalarSize(dataType);
    666    else if (gluShaderUtil.isDataTypeMatrix(dataType))
    667        return gluShaderUtil.getDataTypeMatrixNumRows(dataType);
    668 
    669    throw Error('Unrecognized dataType ' + dataType);
    670 };
    671 
    672 /**
    673 * Returns name of the dataType
    674 * @param {?gluShaderUtil.DataType} dataType shader
    675 * @return {string} dataType name
    676 */
    677 gluShaderUtil.getDataTypeName = function(dataType) {
    678    switch (dataType) {
    679        case gluShaderUtil.DataType.INVALID: return 'invalid';
    680 
    681        case gluShaderUtil.DataType.FLOAT: return 'float';
    682        case gluShaderUtil.DataType.FLOAT_VEC2: return 'vec2';
    683        case gluShaderUtil.DataType.FLOAT_VEC3: return 'vec3';
    684        case gluShaderUtil.DataType.FLOAT_VEC4: return 'vec4';
    685        case gluShaderUtil.DataType.FLOAT_MAT2: return 'mat2';
    686        case gluShaderUtil.DataType.FLOAT_MAT2X3: return 'mat2x3';
    687        case gluShaderUtil.DataType.FLOAT_MAT2X4: return 'mat2x4';
    688        case gluShaderUtil.DataType.FLOAT_MAT3X2: return 'mat3x2';
    689        case gluShaderUtil.DataType.FLOAT_MAT3: return 'mat3';
    690        case gluShaderUtil.DataType.FLOAT_MAT3X4: return 'mat3x4';
    691        case gluShaderUtil.DataType.FLOAT_MAT4X2: return 'mat4x2';
    692        case gluShaderUtil.DataType.FLOAT_MAT4X3: return 'mat4x3';
    693        case gluShaderUtil.DataType.FLOAT_MAT4: return 'mat4';
    694 
    695        case gluShaderUtil.DataType.INT: return 'int';
    696        case gluShaderUtil.DataType.INT_VEC2: return 'ivec2';
    697        case gluShaderUtil.DataType.INT_VEC3: return 'ivec3';
    698        case gluShaderUtil.DataType.INT_VEC4: return 'ivec4';
    699 
    700        case gluShaderUtil.DataType.UINT: return 'uint';
    701        case gluShaderUtil.DataType.UINT_VEC2: return 'uvec2';
    702        case gluShaderUtil.DataType.UINT_VEC3: return 'uvec3';
    703        case gluShaderUtil.DataType.UINT_VEC4: return 'uvec4';
    704 
    705        case gluShaderUtil.DataType.BOOL: return 'bool';
    706        case gluShaderUtil.DataType.BOOL_VEC2: return 'bvec2';
    707        case gluShaderUtil.DataType.BOOL_VEC3: return 'bvec3';
    708        case gluShaderUtil.DataType.BOOL_VEC4: return 'bvec4';
    709 
    710        case gluShaderUtil.DataType.SAMPLER_2D: return 'sampler2D';
    711        case gluShaderUtil.DataType.SAMPLER_CUBE: return 'samplerCube';
    712        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY: return 'sampler2DArray';
    713        case gluShaderUtil.DataType.SAMPLER_3D: return 'sampler3D';
    714 
    715        case gluShaderUtil.DataType.SAMPLER_2D_SHADOW: return 'sampler2DShadow';
    716        case gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW: return 'samplerCubeShadow';
    717        case gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW: return 'sampler2DArrayShadow';
    718 
    719        case gluShaderUtil.DataType.INT_SAMPLER_2D: return 'isampler2D';
    720        case gluShaderUtil.DataType.INT_SAMPLER_CUBE: return 'isamplerCube';
    721        case gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY: return 'isampler2DArray';
    722        case gluShaderUtil.DataType.INT_SAMPLER_3D: return 'isampler3D';
    723 
    724        case gluShaderUtil.DataType.UINT_SAMPLER_2D: return 'usampler2D';
    725        case gluShaderUtil.DataType.UINT_SAMPLER_CUBE: return 'usamplerCube';
    726        case gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY: return 'usampler2DArray';
    727        case gluShaderUtil.DataType.UINT_SAMPLER_3D: return 'usampler3D';
    728    }
    729    throw Error('Unrecognized dataType ' + dataType);
    730 };
    731 
    732 /**
    733 * Returns the gluShaderUtil.DataType from the GL type
    734 * @param {number} glType
    735 * @return {gluShaderUtil.DataType}
    736 */
    737 gluShaderUtil.getDataTypeFromGLType = function(glType) {
    738    switch (glType) {
    739        case gl.FLOAT: return gluShaderUtil.DataType.FLOAT;
    740        case gl.FLOAT_VEC2: return gluShaderUtil.DataType.FLOAT_VEC2;
    741        case gl.FLOAT_VEC3: return gluShaderUtil.DataType.FLOAT_VEC3;
    742        case gl.FLOAT_VEC4: return gluShaderUtil.DataType.FLOAT_VEC4;
    743 
    744        case gl.FLOAT_MAT2: return gluShaderUtil.DataType.FLOAT_MAT2;
    745        case gl.FLOAT_MAT2x3: return gluShaderUtil.DataType.FLOAT_MAT2X3;
    746        case gl.FLOAT_MAT2x4: return gluShaderUtil.DataType.FLOAT_MAT2X4;
    747 
    748        case gl.FLOAT_MAT3x2: return gluShaderUtil.DataType.FLOAT_MAT3X2;
    749        case gl.FLOAT_MAT3: return gluShaderUtil.DataType.FLOAT_MAT3;
    750        case gl.FLOAT_MAT3x4: return gluShaderUtil.DataType.FLOAT_MAT3X4;
    751 
    752        case gl.FLOAT_MAT4x2: return gluShaderUtil.DataType.FLOAT_MAT4X2;
    753        case gl.FLOAT_MAT4x3: return gluShaderUtil.DataType.FLOAT_MAT4X3;
    754        case gl.FLOAT_MAT4: return gluShaderUtil.DataType.FLOAT_MAT4;
    755 
    756        case gl.INT: return gluShaderUtil.DataType.INT;
    757        case gl.INT_VEC2: return gluShaderUtil.DataType.INT_VEC2;
    758        case gl.INT_VEC3: return gluShaderUtil.DataType.INT_VEC3;
    759        case gl.INT_VEC4: return gluShaderUtil.DataType.INT_VEC4;
    760 
    761        case gl.UNSIGNED_INT: return gluShaderUtil.DataType.UINT;
    762        case gl.UNSIGNED_INT_VEC2: return gluShaderUtil.DataType.UINT_VEC2;
    763        case gl.UNSIGNED_INT_VEC3: return gluShaderUtil.DataType.UINT_VEC3;
    764        case gl.UNSIGNED_INT_VEC4: return gluShaderUtil.DataType.UINT_VEC4;
    765 
    766        case gl.BOOL: return gluShaderUtil.DataType.BOOL;
    767        case gl.BOOL_VEC2: return gluShaderUtil.DataType.BOOL_VEC2;
    768        case gl.BOOL_VEC3: return gluShaderUtil.DataType.BOOL_VEC3;
    769        case gl.BOOL_VEC4: return gluShaderUtil.DataType.BOOL_VEC4;
    770 
    771        case gl.SAMPLER_2D: return gluShaderUtil.DataType.SAMPLER_2D;
    772        case gl.SAMPLER_CUBE: return gluShaderUtil.DataType.SAMPLER_CUBE;
    773        case gl.SAMPLER_2D_ARRAY: return gluShaderUtil.DataType.SAMPLER_2D_ARRAY;
    774        case gl.SAMPLER_3D: return gluShaderUtil.DataType.SAMPLER_3D;
    775 
    776        case gl.SAMPLER_2D_SHADOW: return gluShaderUtil.DataType.SAMPLER_2D_SHADOW;
    777        case gl.SAMPLER_CUBE_SHADOW: return gluShaderUtil.DataType.SAMPLER_CUBE_SHADOW;
    778        case gl.SAMPLER_2D_ARRAY_SHADOW: return gluShaderUtil.DataType.SAMPLER_2D_ARRAY_SHADOW;
    779 
    780        case gl.INT_SAMPLER_2D: return gluShaderUtil.DataType.INT_SAMPLER_2D;
    781        case gl.INT_SAMPLER_CUBE: return gluShaderUtil.DataType.INT_SAMPLER_CUBE;
    782        case gl.INT_SAMPLER_2D_ARRAY: return gluShaderUtil.DataType.INT_SAMPLER_2D_ARRAY;
    783        case gl.INT_SAMPLER_3D: return gluShaderUtil.DataType.INT_SAMPLER_3D;
    784 
    785        case gl.UNSIGNED_INT_SAMPLER_2D: return gluShaderUtil.DataType.UINT_SAMPLER_2D;
    786        case gl.UNSIGNED_INT_SAMPLER_CUBE: return gluShaderUtil.DataType.UINT_SAMPLER_CUBE;
    787        case gl.UNSIGNED_INT_SAMPLER_2D_ARRAY: return gluShaderUtil.DataType.UINT_SAMPLER_2D_ARRAY;
    788        case gl.UNSIGNED_INT_SAMPLER_3D: return gluShaderUtil.DataType.UINT_SAMPLER_3D;
    789 
    790        default:
    791            throw new Error('Unrecognized GL type:' + glType);
    792    }
    793 };
    794 
    795 });