[ tor-browser ].git.dasho

glsFboUtil.js (44890B)
      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('modules.shared.glsFboUtil');
     23 goog.require('framework.opengl.gluTextureUtil');
     24 goog.require('framework.opengl.gluStrUtil');
     25 
     26 goog.scope(function() {
     27 
     28    var glsFboUtil = modules.shared.glsFboUtil;
     29    var gluTextureUtil = framework.opengl.gluTextureUtil;
     30    var gluStrUtil = framework.opengl.gluStrUtil;
     31    var DE_ASSERT = function(x) {
     32        if (!x)
     33            throw new Error('Assert failed');
     34    };
     35 
     36    /**
     37    * @constructor
     38    * @template KeyT
     39    * @template ValueT
     40    * @param {function(!KeyT, !KeyT):boolean} comparefnc
     41    */
     42    glsFboUtil.Map = function(comparefnc) {
     43        /** @type {Array<{first: !KeyT, second: ValueT}>} */
     44        this.store = [];
     45        this.compare = comparefnc;
     46        this.length = 0;
     47    };
     48 
     49    /**
     50    * @param {number} num1
     51    * @param {number} num2
     52    * @return {boolean}
     53    */
     54    glsFboUtil.Map.compareNumber = function(num1, num2) {
     55        return num1 < num2;
     56    };
     57 
     58    /**
     59    * @param {!KeyT} key
     60    * @param {ValueT} value
     61    * @return {{first: !KeyT, second: ValueT}}
     62    */
     63    glsFboUtil.Map.prototype.pair = function(key, value) {
     64        return {
     65            first: key,
     66            second: value
     67        };
     68    };
     69 
     70    /**
     71    * @protected
     72    * @param {!KeyT} key
     73    * @return {number}
     74    */
     75    glsFboUtil.Map.prototype.findInsertionPoint = function(key) {
     76        var /** @type {number} */i, /** @type {number} */length;
     77        for (i = 0, length = this.store.length; i < length; ++i) {
     78            if (!this.compare(key, this.store[i].first)) break;
     79        }
     80        return i;
     81    };
     82 
     83    /**
     84    * index should be a value returned from findInsertionPoint.
     85    * returns true if the compare function returns false reflexively
     86    * (i.e. no matter the order in which the keys are passed as arguments).
     87    * @protected
     88    * @param {!KeyT} key
     89    * @param {number} index
     90    * @return {boolean}
     91    */
     92    glsFboUtil.Map.prototype.foundIndexMatches = function(key, index) {
     93        return (
     94            this.store[index] !== undefined &&
     95            !this.compare(this.store[index].first, key)
     96        );
     97    };
     98 
     99    /**
    100    * @param {!KeyT} key
    101    * @return {boolean}
    102    */
    103    glsFboUtil.Map.prototype.isset = function(key) {
    104        return this.foundIndexMatches(key, this.findInsertionPoint(key));
    105    };
    106 
    107    /**
    108    * @param {!KeyT} key
    109    * @param {ValueT} value
    110    */
    111    glsFboUtil.Map.prototype.set = function(key, value) {
    112        var index = this.findInsertionPoint(key);
    113        if (this.foundIndexMatches(key, index)) {
    114            this.store[index].second = value;
    115        } else {
    116            this.store.splice(index, 0, this.pair(key, value));
    117            ++this.length;
    118        }
    119    };
    120 
    121    /**
    122    * @param {!KeyT} key
    123    * @return {?ValueT}
    124    */
    125    glsFboUtil.Map.prototype.remove = function(key) {
    126        var index = this.findInsertionPoint(key);
    127        /** @type {?ValueT} */ var ret = null;
    128        if (this.foundIndexMatches(key, index)) {
    129            ret = this.store[index].second;
    130            this.store.splice(index, 1);
    131            --this.length;
    132        }
    133        return ret;
    134    };
    135 
    136    /**
    137    * @param {KeyT} key
    138    * @return {?{first: KeyT, second: ValueT}}
    139    */
    140    glsFboUtil.Map.prototype.get = function(key) {
    141        var index = this.findInsertionPoint(key);
    142        if (this.foundIndexMatches(key, index)) return this.store[index];
    143        return null;
    144    };
    145 
    146    /**
    147    * @param {KeyT} key
    148    * @return {?ValueT}
    149    */
    150    glsFboUtil.Map.prototype.getValue = function(key) {
    151        var index = this.findInsertionPoint(key);
    152        if (this.foundIndexMatches(key, index)) return this.store[index].second;
    153        return null;
    154    };
    155 
    156    /**
    157    * @param {!KeyT} key
    158    * @param {ValueT} fallback
    159    * @return {ValueT}
    160    */
    161    glsFboUtil.Map.prototype.lookupDefault = function(key, fallback) {
    162        var index = this.findInsertionPoint(key);
    163        if (this.foundIndexMatches(key, index)) return this.store[index].second;
    164        return fallback;
    165    };
    166 
    167    /**
    168    * @param {number} index
    169    * @return {{first: KeyT, second: ValueT}|undefined}
    170    */
    171    glsFboUtil.Map.prototype.getIndex = function(index) {
    172        return this.store[index];
    173    };
    174 
    175    /**
    176    * Use the callback to set the value to be identified by key.
    177    * If a value is already identified by the key, it will be passed to the callback
    178    * @param {!KeyT} key
    179    * @param {function(ValueT=):!ValueT} callback
    180    */
    181    glsFboUtil.Map.prototype.transform = function(key, callback) {
    182        var index = this.findInsertionPoint(key);
    183        if (this.foundIndexMatches(key, index)) {
    184            this.store[index].second = callback(this.store[index].second);
    185        } else {
    186            this.store.splice(index, 0, this.pair(key, callback()));
    187            ++this.length;
    188        }
    189    };
    190 
    191    /**
    192    * removed all elements from the Map
    193    */
    194    glsFboUtil.Map.prototype.clear = function() {
    195        this.store.splice(0, this.length);
    196        this.length = 0;
    197    };
    198 
    199    /**
    200    * @constructor
    201    */
    202    glsFboUtil.FormatDB = function() {
    203        this.m_map = /** @type {glsFboUtil.Map<glsFboUtil.ImageFormat,number>} */(
    204            new glsFboUtil.Map(glsFboUtil.ImageFormat.lessthan)
    205        );
    206    };
    207 
    208    /**
    209    * @param {glsFboUtil.ImageFormat} format
    210    * @param {number} newFlags
    211    */
    212    glsFboUtil.FormatDB.prototype.addFormat = function(format, newFlags) {
    213        this.m_map.transform(format, function(flags) {
    214            return flags | newFlags;
    215        });
    216    };
    217 
    218    /**
    219    * @param {number} requirements
    220    * @return {Array<glsFboUtil.ImageFormat>}
    221    */
    222    glsFboUtil.FormatDB.prototype.getFormats = function(requirements) {
    223        /** @type {Array<glsFboUtil.ImageFormat>} */ var ret = [];
    224        for (var i = 0; i < this.m_map.length; ++i) {
    225            var pair = this.m_map.getIndex(i);
    226            if ((pair.second & requirements) == requirements)
    227            ret.push(pair.first);
    228        }
    229 
    230        return ret;
    231    };
    232 
    233    /**
    234    * @param {glsFboUtil.ImageFormat} format
    235    * @param {number} fallback
    236    * @return {number}
    237    */
    238    glsFboUtil.FormatDB.prototype.getFormatInfo = function(format, fallback) {
    239        return this.m_map.lookupDefault(format, fallback);
    240    };
    241 
    242    /**
    243    * @param {Object} map
    244    * @param {number} key
    245    * @param {number} fallback
    246    * @return {number}
    247    */
    248    glsFboUtil.lookupDefault = function(map, key, fallback) {
    249        return (map[key] !== undefined) ? map[key] : fallback;
    250    };
    251 
    252    /**
    253    * @param {Array<number>} array
    254    * @param {number} item
    255    * @return {boolean}
    256    */
    257    glsFboUtil.contains = function(array, item) {
    258        var l = array.length;
    259        for (var i = 0; i < l; ++i)
    260            if (array[i] == item) return true;
    261        return false;
    262    };
    263 
    264    /**
    265    * @typedef {Array<(number | glsFboUtil.Range<number>)>}
    266    */
    267    glsFboUtil.formatT;
    268 
    269    /**
    270    * @param {glsFboUtil.FormatDB} db
    271    * @param {glsFboUtil.Range<glsFboUtil.formatT>} stdFmts
    272    */
    273    glsFboUtil.addFormats = function(db, stdFmts) {
    274        for (var set = stdFmts.reset(); set = stdFmts.current(); stdFmts.next()) {
    275            for (var fmt = set[1].reset(); fmt = set[1].current(); set[1].next()) {
    276                db.addFormat(glsFboUtil.formatKeyInfo(fmt), set[0]);
    277            }
    278        }
    279    };
    280 
    281    /**
    282    * @param {glsFboUtil.FormatDB} db
    283    * @param {glsFboUtil.Range} extFmts
    284    * @param {WebGLRenderingContextBase=} gl
    285    * @throws {Error}
    286    */
    287    glsFboUtil.addExtFormats = function(db, extFmts, gl) {
    288        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    289        var extensions = gl.getSupportedExtensions();
    290 
    291        // loop through the range, looking at the extentions.
    292        for (var ext = extFmts.reset(); ext = extFmts.current(); extFmts.next()) {
    293            var tokens = ext.extensions.split(/\s+/);
    294 
    295            var supported = function() {
    296                for (var i = 0, l = tokens.length; i < l; ++i)
    297                    if (extensions.indexOf(tokens[i]) === -1) return false;
    298                return true;
    299            }();
    300 
    301            if (supported) {
    302                for (var format = ext.formats.reset(); format = ext.formats.current(); ext.formats.next()) {
    303                    db.addFormat(glsFboUtil.formatKeyInfo(format), ext.flags);
    304                }
    305            }
    306 
    307        }
    308 
    309    };
    310 
    311    /**
    312    * @param {number} glenum
    313    * @param {WebGLRenderingContextBase=} gl
    314    * @return {number}
    315    * @throws {Error}
    316    */
    317    glsFboUtil.formatFlag = function(glenum, gl) {
    318        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    319 
    320        switch (glenum) {
    321         case gl.NONE:
    322            return glsFboUtil.FormatFlags.ANY_FORMAT;
    323         case gl.RENDERBUFFER:
    324            return glsFboUtil.FormatFlags.RENDERBUFFER_VALID;
    325         case gl.TEXTURE:
    326            return glsFboUtil.FormatFlags.TEXTURE_VALID;
    327         case gl.STENCIL_ATTACHMENT:
    328            return glsFboUtil.FormatFlags.STENCIL_RENDERABLE;
    329         case gl.DEPTH_ATTACHMENT:
    330            return glsFboUtil.FormatFlags.DEPTH_RENDERABLE;
    331         default:
    332            if (glenum < gl.COLOR_ATTACHMENT0 || glenum > gl.COLOR_ATTACHMENT15) {
    333                throw new Error('glenum out of range');
    334            }
    335        }
    336        return glsFboUtil.FormatFlags.COLOR_RENDERABLE;
    337    };
    338 
    339    /**
    340    * Remove value from array
    341    * @param {Array} array
    342    * @param {number} value
    343    */
    344    glsFboUtil.remove_from_array = function(array, value) {
    345        var index = 0;
    346        while ((index = array.indexOf(value)) != -1) {
    347            array.splice(index, 1);
    348        }
    349    };
    350 
    351    /**
    352     * glsFboUtil.FormatExtEntry
    353     * @constructor
    354     * @struct
    355     * @param {string=} extensions
    356     * @param {number=} flags
    357     * @param {glsFboUtil.Range=} formats
    358     */
    359    glsFboUtil.FormatExtEntry = function(extensions, flags, formats) {
    360        this.extensions = null;
    361        this.flags = null;
    362        this.formats = null;
    363 
    364        if (extensions !== undefined) {
    365            this.extensions = extensions;
    366            if (flags !== undefined) {
    367                this.flags = flags;
    368                if (formats !== undefined)
    369                    this.formats = formats;
    370            }
    371        }
    372 
    373    };
    374 
    375    /**
    376     * glsFboUtil.Range
    377     * @constructor
    378     * @struct
    379     * @template T
    380     * @param {Array<T>} array
    381     * @param {number=} begin
    382     * @param {number=} end
    383     */
    384    glsFboUtil.Range = function(array, begin, end) {
    385        // @private
    386        this.m_begin = (begin === undefined ? 0 : begin);
    387        // @private
    388        this.m_end = end || array.length;
    389        /**
    390        * @private
    391        * @type {Array<T>}
    392        */
    393        this.m_array = array;
    394        // @private
    395        this.m_index = this.m_begin;
    396    };
    397 
    398    /**
    399    * @return {Array<T>}
    400    */
    401    glsFboUtil.Range.prototype.array = function() {
    402        return this.m_array;
    403    };
    404 
    405    /**
    406    * @return {number}
    407    */
    408    glsFboUtil.Range.prototype.begin = function() {
    409        return this.m_begin;
    410    };
    411 
    412    /**  *generated by script*
    413    * @return {number}
    414    */
    415    glsFboUtil.Range.prototype.end = function() {
    416        return this.m_end;
    417    };
    418 
    419    /**
    420    * Returns the current pointer index as well as the current object
    421    * @param {number} id
    422    * @return {{first: number, second: T}}
    423    */
    424    glsFboUtil.Range.prototype.get = function(id) {
    425        return {
    426            first: id,
    427            second: this.m_array[id]
    428        };
    429    };
    430 
    431    /**
    432    * Sets the internal pointer to the beginning of the range, and returns the first object.
    433    * @return {T}
    434    */
    435    glsFboUtil.Range.prototype.reset = function() {
    436        this.m_index = this.m_begin;
    437        return this.current();
    438    };
    439 
    440    /**
    441    * returns the current object within the specified range. The internal pointer is unaltered.
    442    * @return {T}
    443    */
    444    glsFboUtil.Range.prototype.current = function() {
    445        return this.m_index < this.m_end ? this.m_array[this.m_index] : null;
    446    };
    447 
    448    /**
    449    * Increments the internal pointer
    450    */
    451    glsFboUtil.Range.prototype.next = function() {
    452        ++this.m_index;
    453    };
    454 
    455    /**
    456     * glsFboUtil.rangeArray
    457     * replaces the macro GLS_ARRAY_RANGE
    458     * Creates a new Range object from the specified array, spanning the whole array.
    459     * @template T
    460     * @param {Array<T>} array
    461     * @return {glsFboUtil.Range<T>}
    462     */
    463    glsFboUtil.rangeArray = function(array) {
    464        return new glsFboUtil.Range(array);
    465    };
    466 
    467    /**
    468    * @constructor
    469    * @struct
    470    * @param {number=} format
    471    * @param {number=} unsizedType
    472    */
    473    glsFboUtil.ImageFormat = function(format, unsizedType) {
    474        this.format = format || 0;
    475        //! Type if format is unsized, gl.NONE if sized.
    476        this.unsizedType = unsizedType || 0;
    477 
    478    };
    479 
    480    /**
    481    * @param {!glsFboUtil.ImageFormat} obj1
    482    * @param {!glsFboUtil.ImageFormat} obj2
    483    * @return {boolean}
    484    */
    485    glsFboUtil.ImageFormat.lessthan = function(obj1, obj2) {
    486        return (
    487            (obj1.format < obj2.format) ||
    488            (obj1.format == obj2.format && obj1.unsizedType < obj2.unsizedType)
    489        );
    490    };
    491 
    492    /**
    493    * Sets the object's parameters to gl.NONE
    494    */
    495    glsFboUtil.ImageFormat.prototype.none = function() {
    496        this.format = 0;
    497        this.unsizedType = 0;
    498    };
    499 
    500    /**
    501    * @return {glsFboUtil.ImageFormat}
    502    */
    503    glsFboUtil.ImageFormat.none = function() {
    504        var obj = new glsFboUtil.ImageFormat();
    505        obj.none();
    506        return obj;
    507    };
    508 
    509    // where key is a FormatKey, and a FormatKey is a unsigned 32bit int.
    510 
    511    /**
    512    * @param {number} key
    513    * @return {glsFboUtil.ImageFormat}
    514    */
    515    glsFboUtil.formatKeyInfo = function(key) {
    516        return new glsFboUtil.ImageFormat(
    517            (key & 0x0000ffff),
    518            (key & 0xffff0000) >>> 16
    519        );
    520    };
    521 
    522    /**
    523     * glsFboUtil.Config Class.
    524     * @constructor
    525     */
    526    glsFboUtil.Config = function() {
    527        this.type = glsFboUtil.Config.s_types.CONFIG;
    528        this.target = glsFboUtil.Config.s_target.NONE;
    529    };
    530    /**
    531     * @enum {number}
    532     */
    533    glsFboUtil.Config.s_target = {
    534        NONE: 0,
    535        RENDERBUFFER: 0x8D41,
    536        TEXTURE_2D: 0x0DE1,
    537        TEXTURE_CUBE_MAP: 0x8513,
    538        TEXTURE_3D: 0x806F,
    539        TEXTURE_2D_ARRAY: 0x8C1A,
    540 
    541        FRAMEBUFFER: 0x8D40
    542    };
    543 
    544    // the c++ uses dynamic casts to determain if an object inherits from a
    545    // given class. Here, each class' constructor assigns a bit to obj.type.
    546    // look for the bit to see if an object inherits that class.
    547 
    548    /**
    549    * @enum
    550    */
    551    glsFboUtil.Config.s_types = {
    552        CONFIG: 0x000001,
    553 
    554        IMAGE: 0x000010,
    555        RENDERBUFFER: 0x000020,
    556        TEXTURE: 0x000040,
    557        TEXTURE_FLAT: 0x000080,
    558        TEXTURE_2D: 0x000100,
    559        TEXTURE_CUBE_MAP: 0x000200,
    560        TEXTURE_LAYERED: 0x000400,
    561        TEXTURE_3D: 0x000800,
    562        TEXTURE_2D_ARRAY: 0x001000,
    563 
    564        ATTACHMENT: 0x010000,
    565        ATT_RENDERBUFFER: 0x020000,
    566        ATT_TEXTURE: 0x040000,
    567        ATT_TEXTURE_FLAT: 0x080000,
    568        ATT_TEXTURE_LAYER: 0x100000,
    569 
    570        UNUSED: 0xFFE0E00E
    571    };
    572 
    573    /**
    574     * glsFboUtil.Image Class.
    575     * @constructor
    576     * @extends {glsFboUtil.Config}
    577     */
    578    glsFboUtil.Image = function() {
    579        glsFboUtil.Config.call(this);
    580        this.type |= glsFboUtil.Config.s_types.IMAGE;
    581        this.width = 0;
    582        this.height = 0;
    583        this.internalFormat = new glsFboUtil.ImageFormat();
    584    };
    585 
    586    /**
    587     * glsFboUtil.Renderbuffer Class.
    588     * @constructor
    589     * @extends {glsFboUtil.Image}
    590     */
    591    glsFboUtil.Renderbuffer = function() {
    592        glsFboUtil.Image.call(this);
    593        this.type |= glsFboUtil.Config.s_types.RENDERBUFFER;
    594        this.target = glsFboUtil.Config.s_target.RENDERBUFFER;
    595        this.numSamples = 0;
    596    };
    597 
    598    /**
    599     * glsFboUtil.Texture Class.
    600     * @constructor
    601     * @extends {glsFboUtil.Image}
    602     */
    603    glsFboUtil.Texture = function() {
    604        glsFboUtil.Image.call(this);
    605        this.type |= glsFboUtil.Config.s_types.TEXTURE;
    606        this.numLevels = 1;
    607    };
    608 
    609    /**
    610     * glsFboUtil.TextureFlat Class.
    611     * @constructor
    612     * @extends {glsFboUtil.Texture}
    613     */
    614    glsFboUtil.TextureFlat = function() {
    615        glsFboUtil.Texture.call(this);
    616        this.type |= glsFboUtil.Config.s_types.TEXTURE_FLAT;
    617    };
    618 
    619    /**
    620     * glsFboUtil.Texture2D Class.
    621     * @constructor
    622     * @extends {glsFboUtil.TextureFlat}
    623     */
    624    glsFboUtil.Texture2D = function() {
    625        glsFboUtil.TextureFlat.call(this);
    626        this.type |= glsFboUtil.Config.s_types.TEXTURE_2D;
    627        this.target = glsFboUtil.Config.s_target.TEXTURE_2D;
    628    };
    629 
    630    /**
    631     * glsFboUtil.TextureCubeMap Class.
    632     * @constructor
    633     * @extends {glsFboUtil.TextureFlat}
    634     */
    635    glsFboUtil.TextureCubeMap = function() {
    636        glsFboUtil.TextureFlat.call(this);
    637        this.type |= glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP;
    638        this.target = glsFboUtil.Config.s_target.TEXTURE_CUBE_MAP;
    639    };
    640 
    641    /**
    642     * glsFboUtil.TextureLayered Class.
    643     * @constructor
    644     * @extends {glsFboUtil.Texture}
    645     */
    646    glsFboUtil.TextureLayered = function() {
    647        glsFboUtil.Texture.call(this);
    648        this.type |= glsFboUtil.Config.s_types.TEXTURE_LAYERED;
    649        this.numLayers = 1;
    650    };
    651 
    652    /**
    653     * glsFboUtil.Texture3D Class.
    654     * @constructor
    655     * @extends {glsFboUtil.TextureLayered}
    656     */
    657    glsFboUtil.Texture3D = function() {
    658        glsFboUtil.TextureLayered.call(this);
    659        this.type |= glsFboUtil.Config.s_types.TEXTURE_3D;
    660        this.target = glsFboUtil.Config.s_target.TEXTURE_3D;
    661    };
    662 
    663    /**
    664     * glsFboUtil.Texture2DArray Class.
    665     * @constructor
    666     * @extends {glsFboUtil.TextureLayered}
    667     */
    668    glsFboUtil.Texture2DArray = function() {
    669        glsFboUtil.TextureLayered.call(this);
    670        this.type |= glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY;
    671        this.target = glsFboUtil.Config.s_target.TEXTURE_2D_ARRAY;
    672    };
    673 
    674    /**
    675     * glsFboUtil.Attachment Class.
    676     * @constructor
    677     * @extends {glsFboUtil.Config}
    678     */
    679    glsFboUtil.Attachment = function() {
    680        glsFboUtil.Config.call(this);
    681 
    682        this.type |= glsFboUtil.Config.s_types.ATTACHMENT;
    683 
    684        /** @type {glsFboUtil.Config.s_target} */
    685        this.target = glsFboUtil.Config.s_target.FRAMEBUFFER;
    686 
    687        /** @type {WebGLObject} */
    688        this.imageName = null;
    689    };
    690 
    691    /**
    692    * this function is declared, but has no definition/is unused in the c++
    693    * @param {number} attPoint
    694    * @param {number} image
    695    * @param {number} vfr
    696    */
    697    glsFboUtil.Attachment.prototype.isComplete = function(attPoint, image, vfr) { };
    698 
    699    /**
    700     * glsFboUtil.RenderBufferAttachments Class.
    701     * @constructor
    702     * @extends {glsFboUtil.Attachment}
    703     */
    704    glsFboUtil.RenderbufferAttachment = function() {
    705        glsFboUtil.Attachment.call(this);
    706        this.type |= glsFboUtil.Config.s_types.ATT_RENDERBUFFER;
    707        this.renderbufferTarget = glsFboUtil.Config.s_target.RENDERBUFFER;
    708    };
    709    glsFboUtil.RenderbufferAttachment.prototype = Object.create(glsFboUtil.Attachment.prototype);
    710    glsFboUtil.RenderbufferAttachment.prototype.constructor = glsFboUtil.RenderbufferAttachment;
    711 
    712    /**
    713     * glsFboUtil.TextureAttachment Class.
    714     * @constructor
    715     * @extends {glsFboUtil.Attachment}
    716     */
    717    glsFboUtil.TextureAttachment = function() {
    718        glsFboUtil.Attachment.call(this);
    719        this.type |= glsFboUtil.Config.s_types.ATT_TEXTURE;
    720        this.level = 0;
    721    };
    722    glsFboUtil.TextureAttachment.prototype = Object.create(glsFboUtil.Attachment.prototype);
    723    glsFboUtil.TextureAttachment.prototype.constructor = glsFboUtil.TextureAttachment;
    724 
    725    /**
    726     * glsFboUtil.TextureFlatAttachment Class.
    727     * @constructor
    728     * @extends {glsFboUtil.TextureAttachment}
    729     */
    730    glsFboUtil.TextureFlatAttachment = function() {
    731        glsFboUtil.TextureAttachment.call(this);
    732        this.type |= glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT;
    733        this.texTarget = glsFboUtil.Config.s_target.NONE;
    734    };
    735    glsFboUtil.TextureFlatAttachment.prototype = Object.create(glsFboUtil.TextureAttachment.prototype);
    736    glsFboUtil.TextureFlatAttachment.prototype.constructor = glsFboUtil.TextureFlatAttachment;
    737 
    738    /**
    739     * glsFboUtil.TextureLayerAttachment Class.
    740     * @constructor
    741     * @extends {glsFboUtil.TextureAttachment}
    742     */
    743    glsFboUtil.TextureLayerAttachment = function() {
    744        glsFboUtil.TextureAttachment.call(this);
    745        this.type |= glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER;
    746        this.layer = 0;
    747    };
    748    glsFboUtil.TextureLayerAttachment.prototype = Object.create(glsFboUtil.TextureAttachment.prototype);
    749    glsFboUtil.TextureLayerAttachment.prototype.constructor = glsFboUtil.TextureLayerAttachment;
    750 
    751    // these are a collection of helper functions for creating various gl textures.
    752    glsFboUtil.glsup = function() {
    753 
    754        var glInit = function(cfg, gl) {
    755            if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_2D) != 0) {
    756                glInitFlat(cfg, glTarget(cfg, gl), gl);
    757 
    758            } else if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP) != 0) {
    759                for (var i = gl.TEXTURE_CUBE_MAP_NEGATIVE_X; i <= gl.TEXTURE_CUBE_MAP_POSITIVE_Z; ++i)
    760                    glInitFlat(cfg, i, gl);
    761            } else if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_3D) != 0) {
    762                glInitLayered(cfg, 2, gl);
    763 
    764            } else if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY) != 0) {
    765                glInitLayered(cfg, 1, gl);
    766            }
    767        };
    768 
    769        var glInitFlat = function(cfg, target, gl) {
    770            var format = glsFboUtil.transferImageFormat(cfg.internalFormat, gl);
    771            var w = cfg.width;
    772            var h = cfg.height;
    773            for (var level = 0; level < cfg.numLevels; ++level) {
    774                gl.texImage2D(
    775                    target, level, cfg.internalFormat.format,
    776                    w, h, 0, format.format, format.dataType, null
    777                );
    778                w = Math.max(1, w / 2);
    779                h = Math.max(1, h / 2);
    780            }
    781        };
    782 
    783        var glInitLayered = function(cfg, depth_divider, gl) {
    784            var format = glsFboUtil.transferImageFormat(cfg.internalFormat, gl);
    785            var w = cfg.width;
    786            var h = cfg.height;
    787            var depth = cfg.numLayers;
    788            for (var level = 0; level < cfg.numLevels; ++level) {
    789                gl.texImage3D(
    790                    glTarget(cfg, gl), level, cfg.internalFormat.format,
    791                    w, h, depth, 0, format.format, format.dataType, null
    792                );
    793                w = Math.max(1, w / 2);
    794                h = Math.max(1, h / 2);
    795                depth = Math.max(1, depth / depth_divider);
    796            }
    797        };
    798 
    799        var glCreate = function(cfg, gl) {
    800            if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    801 
    802            if (cfg.type & glsFboUtil.Config.s_types.RENDERBUFFER) {
    803                var ret = gl.createRenderbuffer();
    804                gl.bindRenderbuffer(gl.RENDERBUFFER, ret);
    805 
    806                if (cfg.numSamples == 0) {
    807                    gl.renderbufferStorage(
    808                        gl.RENDERBUFFER,
    809                        cfg.internalFormat.format,
    810                        cfg.width, cfg.height
    811                    );
    812                } else {
    813                    gl.renderbufferStorageMultisample(
    814                        gl.RENDERBUFFER,
    815                        cfg.numSamples,
    816                        cfg.internalFormat.format,
    817                        cfg.width, cfg.height
    818                    );
    819                }
    820                gl.bindRenderbuffer(gl.RENDERBUFFER, null);
    821 
    822            } else if (cfg.type & glsFboUtil.Config.s_types.TEXTURE) {
    823                var ret = gl.createTexture();
    824                gl.bindTexture(glTarget(cfg, gl), ret);
    825                glInit(cfg, gl);
    826                gl.bindTexture(glTarget(cfg, gl), null);
    827 
    828            } else {
    829                throw new Error('Impossible image type');
    830            }
    831            return ret;
    832        };
    833 
    834        var glTarget = function(cfg, gl) {
    835            if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    836            var mask = (
    837                glsFboUtil.Config.s_types.RENDERBUFFER |
    838                glsFboUtil.Config.s_types.TEXTURE_2D |
    839                glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP |
    840                glsFboUtil.Config.s_types.TEXTURE_3D |
    841                glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY
    842            );
    843            switch (cfg.type & mask) {
    844                case glsFboUtil.Config.s_types.RENDERBUFFER: return gl.RENDERBUFFER;
    845                case glsFboUtil.Config.s_types.TEXTURE_2D: return gl.TEXTURE_2D;
    846                case glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP: return gl.TEXTURE_CUBE_MAP;
    847                case glsFboUtil.Config.s_types.TEXTURE_3D: return gl.TEXTURE_3D;
    848                case glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY: return gl.TEXTURE_2D_ARRAY;
    849                default: break;
    850            }
    851            throw new Error('Impossible image type.');
    852        };
    853 
    854        var glDelete = function(cfg, img, gl) {
    855            if (cfg.type & glsFboUtil.Config.s_types.RENDERBUFFER)
    856                gl.deleteRenderbuffer(img);
    857            else if (cfg.type & glsFboUtil.Config.s_types.TEXTURE)
    858                gl.deleteTexture(img);
    859            else
    860                throw new Error('Impossible image type');
    861        };
    862 
    863        return {
    864            create: glCreate,
    865            remove: glDelete
    866        };
    867 
    868    }();
    869 
    870    /**  *generated by script*
    871    * @param {number} img
    872    * @return {number}
    873    */
    874    glsFboUtil.imageNumSamples = function(img) {
    875        return (img.numSamples != undefined) ? img.numSamples : 0;
    876    };
    877 
    878    /**  *generated by script*
    879    * @param {glsFboUtil.Attachment} att
    880    * @param {number} attPoint
    881    * @param {WebGLRenderingContextBase=} gl
    882    * @throws {Error}
    883    */
    884    glsFboUtil.attachAttachment = function(att, attPoint, gl) {
    885        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    886 
    887        var mask = (
    888            glsFboUtil.Config.s_types.ATT_RENDERBUFFER |
    889            glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT |
    890            glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER
    891        );
    892 
    893        switch (att.type & mask) {
    894            case glsFboUtil.Config.s_types.ATT_RENDERBUFFER:
    895                gl.framebufferRenderbuffer(
    896                    att.target, attPoint, att.renderbufferTarget, /** @type {WebGLRenderbuffer} */(att.imageName)
    897                );
    898                break;
    899            case glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT:
    900                gl.framebufferTexture2D(
    901                    att.target, attPoint, att.texTarget, /** @type {WebGLTexture} */(att.imageName), att.level
    902                );
    903                break;
    904            case glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER:
    905                gl.framebufferTextureLayer(
    906                    att.target, attPoint, /** @type {WebGLTexture} */(att.imageName), att.level, att.layer
    907                );
    908                break;
    909            default:
    910                throw new Error('Impossible attachment type');
    911        }
    912 
    913    };
    914 
    915    /**  *generated by script*
    916    * @param {glsFboUtil.Attachment} att
    917    * @param {WebGLRenderingContextBase=} gl
    918    * @return {number}
    919    * @throws {Error}
    920    */
    921    glsFboUtil.attachmentType = function(att, gl) {
    922        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    923 
    924        if (att.type & glsFboUtil.Config.s_types.ATT_RENDERBUFFER) {
    925            return gl.RENDERBUFFER;
    926        }
    927        if (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE) {
    928            return gl.TEXTURE;
    929        }
    930        throw new Error('Impossible attachment type.');
    931 
    932    };
    933 
    934    /**
    935    * @param {glsFboUtil.Attachment} att
    936    * @return {number}
    937    * @throws {Error}
    938    */
    939    glsFboUtil.textureLayer = function(att) {
    940        if (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT) return 0;
    941        if (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER) return att.layer;
    942        throw new Error('Impossible attachment type.');
    943    };
    944 
    945    /**
    946    * @param {glsFboUtil.Checker} cctx
    947    * @param {glsFboUtil.Attachment} att
    948    * @param {number} attPoint
    949    * @param {glsFboUtil.Image} image
    950    * @param {glsFboUtil.FormatDB} db
    951    * @param {WebGLRenderingContextBase=} gl
    952    * @throws {Error}
    953    */
    954    glsFboUtil.checkAttachmentCompleteness = function(cctx, att, attPoint, image, db, gl) {
    955        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
    956 
    957        // GLES2 4.4.5 / GLES3 4.4.4, "glsFboUtil.Framebuffer attachment completeness"
    958        if (
    959            (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE) &&
    960            (image.type & glsFboUtil.Config.s_types.TEXTURE_LAYERED)
    961        ) {
    962            // GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is
    963            // TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a
    964            // three-dimensional texture, then the value of
    965            // FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the depth
    966            // of the texture.
    967            //
    968            // GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is
    969            // TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a
    970            // two-dimensional array texture, then the value of
    971            // FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the
    972            // number of layers in the texture.
    973            cctx.addFBOStatus(
    974                glsFboUtil.textureLayer(att) < image.numLayers,
    975                gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
    976            );
    977        }
    978 
    979        // "The width and height of image are non-zero."
    980        cctx.addFBOStatus(
    981            image.width > 0 && image.height > 0,
    982            gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
    983        );
    984 
    985        // Check for renderability
    986        var flags = db.getFormatInfo(image.internalFormat, glsFboUtil.FormatFlags.ANY_FORMAT);
    987 
    988        // If the format does not have the proper renderability flag, the
    989        // completeness check _must_ fail.
    990        cctx.addFBOStatus(
    991            (flags & glsFboUtil.formatFlag(attPoint)) != 0,
    992            gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
    993        );
    994 
    995        // If the format is only optionally renderable, the completeness check _can_ fail.
    996        cctx.addPotentialFBOStatus(
    997            (flags & glsFboUtil.FormatFlags.REQUIRED_RENDERABLE) != 0,
    998            gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
    999        );
   1000 
   1001    };
   1002 
   1003    // replaces GLS_UNSIZED_FORMATKEY
   1004 
   1005    /**
   1006    * All params and return types for this function are 32 bit
   1007    * @param {number} format
   1008    * @param {number} type
   1009    * @return {number}
   1010    */
   1011    glsFboUtil.formatkey = function(format, type) {
   1012        // The formatkey value should be 32-bit unsigned int.
   1013        return ((type << 16) >>> 0 | format) & 0xFFFFFFFF;
   1014    };
   1015 
   1016    /**
   1017    * @enum
   1018    */
   1019    glsFboUtil.FormatFlags = {
   1020        ANY_FORMAT: 0x00,
   1021        COLOR_RENDERABLE: 0x01,
   1022        DEPTH_RENDERABLE: 0x02,
   1023        STENCIL_RENDERABLE: 0x04,
   1024        RENDERBUFFER_VALID: 0x08,
   1025        TEXTURE_VALID: 0x10,
   1026        REQUIRED_RENDERABLE: 0x20 //< Without this, renderability is allowed, not required.
   1027    };
   1028 
   1029    /**
   1030    * A framebuffer configuration
   1031    * @constructor
   1032    * @param {WebGLRenderingContextBase=} gl
   1033    */
   1034    glsFboUtil.Framebuffer = function(gl) {
   1035        this.m_gl = gl || window.gl;
   1036        this.fbid = 0;
   1037 
   1038        var fbidCompare = function(obj1, obj2) {
   1039            return obj1._fbid < obj2._fbid;
   1040        };
   1041 
   1042        this.attachments = /** @type {glsFboUtil.Map<number,glsFboUtil.Attachment>} */(
   1043            new glsFboUtil.Map(glsFboUtil.Map.compareNumber)
   1044        );
   1045        this.textures = /** @type {glsFboUtil.Map<Object,glsFboUtil.Texture>} */(
   1046            new glsFboUtil.Map(fbidCompare)
   1047        );
   1048        this.rbos = /** @type {glsFboUtil.Map<Object,glsFboUtil.Renderbuffer>} */(
   1049            new glsFboUtil.Map(fbidCompare)
   1050        );
   1051    };
   1052 
   1053    /**
   1054    * @param {number} attPoint
   1055    * @param {glsFboUtil.Attachment} att
   1056    */
   1057    glsFboUtil.Framebuffer.prototype.attach = function(attPoint, att) {
   1058        if (!att) {
   1059            this.attachments.remove(attPoint);
   1060        } else {
   1061            this.attachments.set(attPoint, att);
   1062        }
   1063    };
   1064 
   1065    /**
   1066    * @param {WebGLTexture} texName
   1067    * @param {glsFboUtil.Texture} texCfg
   1068    */
   1069    glsFboUtil.Framebuffer.prototype.setTexture = function(texName, texCfg) {
   1070        texName._fbid = this.fbid++;
   1071        this.textures.set(texName, texCfg);
   1072    };
   1073 
   1074    /**
   1075    * @param {WebGLRenderbuffer} rbName
   1076    * @param {glsFboUtil.Renderbuffer} rbCfg
   1077    */
   1078    glsFboUtil.Framebuffer.prototype.setRbo = function(rbName, rbCfg) {
   1079        rbName._fbid = this.fbid++;
   1080        this.rbos.set(rbName, rbCfg);
   1081    };
   1082 
   1083    /**
   1084    * @param {number} type
   1085    * @param {WebGLObject} imgName
   1086    * @return {glsFboUtil.Image}
   1087    * @throws {Error}
   1088    */
   1089    glsFboUtil.Framebuffer.prototype.getImage = function(type, imgName) {
   1090        switch (type) {
   1091            case this.m_gl.TEXTURE: return this.textures.lookupDefault(/** @type {WebGLTexture} */(imgName), null);
   1092            case this.m_gl.RENDERBUFFER: return this.rbos.lookupDefault(/** @type {WebGLTexture} */(imgName), null);
   1093            default: break;
   1094        }
   1095        throw new Error('Bad image type.');
   1096    };
   1097 
   1098    /**
   1099    * @constructor
   1100    * @extends {glsFboUtil.Framebuffer}
   1101    * @param {WebGLFramebuffer} fbo
   1102    * @param {number} target
   1103    * @param {WebGLRenderingContextBase=} gl
   1104    */
   1105    glsFboUtil.FboBuilder = function(fbo, target, gl) {
   1106        glsFboUtil.Framebuffer.call(this, gl);
   1107 
   1108        this.m_gl = gl || window.gl;
   1109        this.m_target = target;
   1110        this.m_configs = [];
   1111        this.m_error = this.m_gl.NO_ERROR;
   1112 
   1113        this.m_gl.bindFramebuffer(this.m_target, fbo);
   1114 
   1115    };
   1116 
   1117    glsFboUtil.FboBuilder.prototype = Object.create(glsFboUtil.Framebuffer.prototype);
   1118    glsFboUtil.FboBuilder.prototype.constructor = glsFboUtil.FboBuilder;
   1119 
   1120    glsFboUtil.FboBuilder.prototype.deinit = function() {
   1121 
   1122        var pair;
   1123        for (var i = 0; i < this.textures.length; ++i) {
   1124            pair = this.textures.getIndex(i);
   1125            glsFboUtil.glsup.remove(pair.second, pair.first, this.m_gl);
   1126        }
   1127        this.textures.clear();
   1128 
   1129        for (var i = 0; i < this.rbos.length; ++i) {
   1130            pair = this.rbos.getIndex(i);
   1131            glsFboUtil.glsup.remove(pair.second, pair.first, this.m_gl);
   1132        }
   1133        this.rbos.clear();
   1134 
   1135        this.m_gl.bindFramebuffer(this.m_target, null);
   1136 /*
   1137        for (var i = 0 ; i < this.m_configs.length ; ++i) {
   1138            delete this.m_configs[i];
   1139        }
   1140 //*/
   1141    };
   1142 
   1143    /**
   1144    * @param {number} attPoint
   1145    * @param {glsFboUtil.Attachment} att
   1146    */
   1147    glsFboUtil.FboBuilder.prototype.glAttach = function(attPoint, att) {
   1148        if (!att) {
   1149            this.m_gl.framebufferRenderbuffer(this.m_target, attPoint, this.m_gl.RENDERBUFFER, null);
   1150        } else {
   1151            glsFboUtil.attachAttachment(att, attPoint, this.m_gl);
   1152        }
   1153        this.checkError();
   1154        this.attach(attPoint, att);
   1155    };
   1156 
   1157    /**
   1158    * @param {glsFboUtil.Texture} texCfg
   1159    * @return {WebGLTexture}
   1160    */
   1161    glsFboUtil.FboBuilder.prototype.glCreateTexture = function(texCfg) {
   1162        var texName = glsFboUtil.glsup.create(texCfg, this.m_gl);
   1163        this.checkError();
   1164        this.setTexture(texName, texCfg);
   1165        return texName;
   1166    };
   1167 
   1168    /**  *generated by script*
   1169    * @param {glsFboUtil.Renderbuffer} rbCfg
   1170    * @return {WebGLRenderbuffer}
   1171    */
   1172    glsFboUtil.FboBuilder.prototype.glCreateRbo = function(rbCfg) {
   1173        var rbName = glsFboUtil.glsup.create(rbCfg, this.m_gl);
   1174        this.checkError();
   1175        this.setRbo(rbName, rbCfg);
   1176        return rbName;
   1177    };
   1178 
   1179    /**
   1180    * @param {function(new:glsFboUtil.Config)} Definition
   1181    * @return {glsFboUtil.Config}
   1182    */
   1183    glsFboUtil.FboBuilder.prototype.makeConfig = function(Definition) {
   1184        var cfg = new Definition();
   1185        this.m_configs.push(cfg);
   1186        return cfg;
   1187    };
   1188 
   1189    /**
   1190    */
   1191    glsFboUtil.FboBuilder.prototype.checkError = function() {
   1192        var error = this.m_gl.getError();
   1193        if (error != this.m_gl.NO_ERROR && this.m_error == this.m_gl.NO_ERROR) {
   1194            this.m_error = error;
   1195        }
   1196    };
   1197 
   1198    /**  *generated by script*
   1199    * @return {number}
   1200    */
   1201    glsFboUtil.FboBuilder.prototype.getError = function() {
   1202        return this.m_error;
   1203    };
   1204 
   1205    glsFboUtil.isFramebufferStatus = function(fboStatus) {
   1206        return gluStrUtil.getFramebufferStatusName(fboStatus) != '';
   1207    }
   1208 
   1209    glsFboUtil.isErrorCode = function(errorCode) {
   1210        return gluStrUtil.getErrorName(errorCode) != '';
   1211    }
   1212 
   1213    /**
   1214    * @typedef {funcion(): glsFboUtil.ValidStatusCodes}
   1215    */
   1216    glsFboUtil.ValidStatusCodes = function() {
   1217        this.m_errorCodes = [];
   1218        this.m_errorStatusCodes = [];
   1219        this.m_allowComplete = false;
   1220    };
   1221 
   1222    glsFboUtil.ValidStatusCodes.prototype.isFBOStatusValid = function(fboStatus) {
   1223        if (fboStatus == gl.FRAMEBUFFER_COMPLETE)
   1224            return this.m_allowComplete;
   1225        else {
   1226            for(var ndx = 0; ndx < this.m_errorStatusCodes.length; ++ndx) {
   1227                if (this.m_errorStatusCodes[ndx] == fboStatus)
   1228                    return true;
   1229            }
   1230            return false;
   1231        }
   1232    };
   1233 
   1234    glsFboUtil.ValidStatusCodes.prototype.isFBOStatusRequired = function(fboStatus) {
   1235        if (fboStatus == gl.FRAMEBUFFER_COMPLETE)
   1236            return this.m_allowComplete && this.m_errorStatusCodes.length == 0;
   1237        else
   1238            // fboStatus is the only allowed error status and succeeding is forbidden
   1239            return !this.m_allowComplete && this.m_errorStatusCodes.length == 1 && this.m_errorStatusCodes[0] == fboStatus;
   1240    };
   1241 
   1242    glsFboUtil.ValidStatusCodes.prototype.isErrorCodeValid = function(errorCode) {
   1243        if (errorCode == gl.NO_ERROR)
   1244            return this.m_errorCodes.length == 0;
   1245        else {
   1246            // rule violation exists?
   1247            for (var ndx = 0; ndx < this.m_errorCodes.length; ++ndx) {
   1248                if (this.m_errorCodes[ndx] == errorCode)
   1249                    return true;
   1250            }
   1251            return false;
   1252        }
   1253    };
   1254 
   1255    glsFboUtil.ValidStatusCodes.prototype.isErrorCodeRequired = function(errorCode) {
   1256        if (this.m_errorCodes.length == 0 && errorCode == gl.NO_ERROR)
   1257            return true;
   1258        else
   1259            // only this error code listed
   1260            return this.m_errorCodes.length == 1 && merrorCodes[0] == errorCode;
   1261    };
   1262 
   1263    glsFboUtil.ValidStatusCodes.prototype.addErrorCode = function(error) {
   1264        DE_ASSERT(glsFboUtil.isErrorCode(error));
   1265        DE_ASSERT(error != gl.NO_ERROR)
   1266        this.m_errorCodes.push(error);
   1267    };
   1268 
   1269    glsFboUtil.ValidStatusCodes.prototype.addFBOErrorStatus = function(status) {
   1270        DE_ASSERT(glsFboUtil.isFramebufferStatus(status));
   1271        DE_ASSERT(status != gl.FRAMEBUFFER_COMPLETE)
   1272        this.m_errorStatusCodes.push(status);
   1273    };
   1274 
   1275    glsFboUtil.ValidStatusCodes.prototype.setAllowComplete = function(b) {
   1276        this.m_allowComplete = b;
   1277    };
   1278 
   1279    /**
   1280    * @typedef {function(): glsFboUtil.Checker}
   1281    */
   1282    glsFboUtil.CheckerFactory;
   1283 
   1284    /**
   1285    * @constructor
   1286    * @param {WebGLRenderingContextBase=} gl
   1287    * @throws {Error}
   1288    */
   1289    glsFboUtil.Checker = function(gl) {
   1290        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
   1291 
   1292        this.m_statusCodes = new glsFboUtil.ValidStatusCodes();
   1293        this.m_statusCodes.setAllowComplete(true);
   1294 
   1295        if (typeof(this.check) != 'function')
   1296            throw new Error('Constructor called on virtual class: glsFboUtil.Checker');
   1297    };
   1298 
   1299    /**
   1300    * @param {boolean} condition
   1301    * @param {number} error
   1302    */
   1303    glsFboUtil.Checker.prototype.addGLError = function(condition, error) {
   1304        if (!condition) {
   1305            this.m_statusCodes.addErrorCode(error);
   1306            this.m_statusCodes.setAllowComplete(false);
   1307        }
   1308    };
   1309 
   1310    /**
   1311    * @param {boolean} condition
   1312    * @param {number} error
   1313    */
   1314    glsFboUtil.Checker.prototype.addPotentialGLError = function(condition, error) {
   1315        if (!condition) {
   1316            this.m_statusCodes.addErrorCode(error);
   1317        }
   1318    };
   1319 
   1320    /**
   1321    * @param {boolean} condition
   1322    * @param {number} status
   1323    */
   1324    glsFboUtil.Checker.prototype.addFBOStatus = function(condition, status) {
   1325        if (!condition) {
   1326            this.m_statusCodes.addFBOErrorStatus(status);
   1327            this.m_statusCodes.setAllowComplete(false);
   1328        }
   1329    };
   1330 
   1331    /**
   1332    * @param {boolean} condition
   1333    * @param {number} status
   1334    */
   1335    glsFboUtil.Checker.prototype.addPotentialFBOStatus = function(condition, status) {
   1336        if (!condition) {
   1337            this.m_statusCodes.addFBOErrorStatus(status);
   1338        }
   1339    };
   1340 
   1341    /**
   1342    * @return {Array<number>}
   1343    */
   1344    glsFboUtil.Checker.prototype.getStatusCodes = function () {
   1345        return this.m_statusCodes;
   1346    };
   1347 
   1348    /**
   1349    * @param {glsFboUtil.ImageFormat} imgFormat
   1350    * @param {WebGLRenderingContextBase=} gl
   1351    * @return {gluTextureUtil.TransferFormat}
   1352    * @throws {Error}
   1353    */
   1354    glsFboUtil.transferImageFormat = function(imgFormat, gl) {
   1355        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
   1356        if (imgFormat.unsizedType == gl.NONE)
   1357            return gluTextureUtil.getTransferFormat(gluTextureUtil.mapGLInternalFormat(imgFormat.format));
   1358        else
   1359            return new gluTextureUtil.TransferFormat(imgFormat.format, imgFormat.unsizedType);
   1360    };
   1361 
   1362    // FormatDB, CheckerFactory
   1363 
   1364    /**
   1365    * @constructor
   1366    * @param {glsFboUtil.FormatDB} formats
   1367    * @param {glsFboUtil.CheckerFactory} factory
   1368    */
   1369    glsFboUtil.FboVerifier = function(formats, factory) {
   1370        this.m_formats = formats;
   1371        this.m_factory = factory;
   1372    };
   1373    // config::Framebuffer
   1374    glsFboUtil.FboVerifier.prototype.validStatusCodes = function(cfg, gl) {
   1375        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
   1376 
   1377        /** @type {glsFboUtil.Checker} */
   1378        var cctx = this.m_factory();
   1379 
   1380        for (var id = 0; id < cfg.textures.length; ++id) {
   1381            var flags = this.m_formats.getFormatInfo(cfg.textures.getIndex(id).second.internalFormat, glsFboUtil.FormatFlags.ANY_FORMAT);
   1382            var textureIsValid = (flags & glsFboUtil.FormatFlags.TEXTURE_VALID) != 0;
   1383            cctx.addGLError(textureIsValid, gl.INVALID_ENUM);
   1384            cctx.addGLError(textureIsValid, gl.INVALID_OPERATION);
   1385            cctx.addGLError(textureIsValid, gl.INVALID_VALUE);
   1386        }
   1387 
   1388        for (var id = 0; id < cfg.rbos.length; ++id) {
   1389            var flags = this.m_formats.getFormatInfo(cfg.rbos.getIndex(id).second.internalFormat, glsFboUtil.FormatFlags.ANY_FORMAT);
   1390            var rboIsValid = (flags & glsFboUtil.FormatFlags.RENDERBUFFER_VALID) != 0;
   1391            cctx.addGLError(rboIsValid, gl.INVALID_ENUM);
   1392        }
   1393 
   1394        var count = 0;
   1395        for (var index = 0; index < cfg.attachments.length; ++index) {
   1396            var attPoint = cfg.attachments.getIndex(index).first;
   1397            var att = cfg.attachments.getIndex(index).second;
   1398            /** @type {glsFboUtil.Image}*/
   1399            var image = cfg.getImage(glsFboUtil.attachmentType(att, gl), att.imageName);
   1400            glsFboUtil.checkAttachmentCompleteness(cctx, att, attPoint, image, this.m_formats, gl);
   1401            cctx.check(attPoint, att, image);
   1402            ++count;
   1403        }
   1404 
   1405        // "There is at least one image attached to the framebuffer."
   1406        // TODO: support XXX_framebuffer_no_attachments
   1407        cctx.addFBOStatus(count > 0, gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
   1408 
   1409        return cctx.getStatusCodes();
   1410 
   1411    };
   1412 
   1413 });
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE