/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

'use strict';
goog.provide('modules.shared.glsFboUtil');
goog.require('framework.opengl.gluTextureUtil');
goog.require('framework.opengl.gluStrUtil');

goog.scope(function() {

    var glsFboUtil = modules.shared.glsFboUtil;
    var gluTextureUtil = framework.opengl.gluTextureUtil;
    var gluStrUtil = framework.opengl.gluStrUtil;
    var DE_ASSERT = function(x) {
        if (!x)
            throw new Error('Assert failed');
    };

    /**
    * @constructor
    * @template KeyT
    * @template ValueT
    * @param {function(!KeyT, !KeyT):boolean} comparefnc
    */
    glsFboUtil.Map = function(comparefnc) {
        /** @type {Array<{first: !KeyT, second: ValueT}>} */
        this.store = [];
        this.compare = comparefnc;
        this.length = 0;
    };

    /**
    * @param {number} num1
    * @param {number} num2
    * @return {boolean}
    */
    glsFboUtil.Map.compareNumber = function(num1, num2) {
        return num1 < num2;
    };

    /**
    * @param {!KeyT} key
    * @param {ValueT} value
    * @return {{first: !KeyT, second: ValueT}}
    */
    glsFboUtil.Map.prototype.pair = function(key, value) {
        return {
            first: key,
            second: value
        };
    };

    /**
    * @protected
    * @param {!KeyT} key
    * @return {number}
    */
    glsFboUtil.Map.prototype.findInsertionPoint = function(key) {
        var /** @type {number} */i, /** @type {number} */length;
        for (i = 0, length = this.store.length; i < length; ++i) {
            if (!this.compare(key, this.store[i].first)) break;
        }
        return i;
    };

    /**
    * index should be a value returned from findInsertionPoint.
    * returns true if the compare function returns false reflexively
    * (i.e. no matter the order in which the keys are passed as arguments).
    * @protected
    * @param {!KeyT} key
    * @param {number} index
    * @return {boolean}
    */
    glsFboUtil.Map.prototype.foundIndexMatches = function(key, index) {
        return (
            this.store[index] !== undefined &&
            !this.compare(this.store[index].first, key)
        );
    };

    /**
    * @param {!KeyT} key
    * @return {boolean}
    */
    glsFboUtil.Map.prototype.isset = function(key) {
        return this.foundIndexMatches(key, this.findInsertionPoint(key));
    };

    /**
    * @param {!KeyT} key
    * @param {ValueT} value
    */
    glsFboUtil.Map.prototype.set = function(key, value) {
        var index = this.findInsertionPoint(key);
        if (this.foundIndexMatches(key, index)) {
            this.store[index].second = value;
        } else {
            this.store.splice(index, 0, this.pair(key, value));
            ++this.length;
        }
    };

    /**
    * @param {!KeyT} key
    * @return {?ValueT}
    */
    glsFboUtil.Map.prototype.remove = function(key) {
        var index = this.findInsertionPoint(key);
        /** @type {?ValueT} */ var ret = null;
        if (this.foundIndexMatches(key, index)) {
            ret = this.store[index].second;
            this.store.splice(index, 1);
            --this.length;
        }
        return ret;
    };

    /**
    * @param {KeyT} key
    * @return {?{first: KeyT, second: ValueT}}
    */
    glsFboUtil.Map.prototype.get = function(key) {
        var index = this.findInsertionPoint(key);
        if (this.foundIndexMatches(key, index)) return this.store[index];
        return null;
    };

    /**
    * @param {KeyT} key
    * @return {?ValueT}
    */
    glsFboUtil.Map.prototype.getValue = function(key) {
        var index = this.findInsertionPoint(key);
        if (this.foundIndexMatches(key, index)) return this.store[index].second;
        return null;
    };

    /**
    * @param {!KeyT} key
    * @param {ValueT} fallback
    * @return {ValueT}
    */
    glsFboUtil.Map.prototype.lookupDefault = function(key, fallback) {
        var index = this.findInsertionPoint(key);
        if (this.foundIndexMatches(key, index)) return this.store[index].second;
        return fallback;
    };

    /**
    * @param {number} index
    * @return {{first: KeyT, second: ValueT}|undefined}
    */
    glsFboUtil.Map.prototype.getIndex = function(index) {
        return this.store[index];
    };

    /**
    * Use the callback to set the value to be identified by key.
    * If a value is already identified by the key, it will be passed to the callback
    * @param {!KeyT} key
    * @param {function(ValueT=):!ValueT} callback
    */
    glsFboUtil.Map.prototype.transform = function(key, callback) {
        var index = this.findInsertionPoint(key);
        if (this.foundIndexMatches(key, index)) {
            this.store[index].second = callback(this.store[index].second);
        } else {
            this.store.splice(index, 0, this.pair(key, callback()));
            ++this.length;
        }
    };

    /**
    * removed all elements from the Map
    */
    glsFboUtil.Map.prototype.clear = function() {
        this.store.splice(0, this.length);
        this.length = 0;
    };

    /**
    * @constructor
    */
    glsFboUtil.FormatDB = function() {
        this.m_map = /** @type {glsFboUtil.Map<glsFboUtil.ImageFormat,number>} */(
            new glsFboUtil.Map(glsFboUtil.ImageFormat.lessthan)
        );
    };

    /**
    * @param {glsFboUtil.ImageFormat} format
    * @param {number} newFlags
    */
    glsFboUtil.FormatDB.prototype.addFormat = function(format, newFlags) {
        this.m_map.transform(format, function(flags) {
            return flags | newFlags;
        });
    };

    /**
    * @param {number} requirements
    * @return {Array<glsFboUtil.ImageFormat>}
    */
    glsFboUtil.FormatDB.prototype.getFormats = function(requirements) {
        /** @type {Array<glsFboUtil.ImageFormat>} */ var ret = [];
        for (var i = 0; i < this.m_map.length; ++i) {
            var pair = this.m_map.getIndex(i);
            if ((pair.second & requirements) == requirements)
            ret.push(pair.first);
        }

        return ret;
    };

    /**
    * @param {glsFboUtil.ImageFormat} format
    * @param {number} fallback
    * @return {number}
    */
    glsFboUtil.FormatDB.prototype.getFormatInfo = function(format, fallback) {
        return this.m_map.lookupDefault(format, fallback);
    };

    /**
    * @param {Object} map
    * @param {number} key
    * @param {number} fallback
    * @return {number}
    */
    glsFboUtil.lookupDefault = function(map, key, fallback) {
        return (map[key] !== undefined) ? map[key] : fallback;
    };

    /**
    * @param {Array<number>} array
    * @param {number} item
    * @return {boolean}
    */
    glsFboUtil.contains = function(array, item) {
        var l = array.length;
        for (var i = 0; i < l; ++i)
            if (array[i] == item) return true;
        return false;
    };

    /**
    * @typedef {Array<(number | glsFboUtil.Range<number>)>}
    */
    glsFboUtil.formatT;

    /**
    * @param {glsFboUtil.FormatDB} db
    * @param {glsFboUtil.Range<glsFboUtil.formatT>} stdFmts
    */
    glsFboUtil.addFormats = function(db, stdFmts) {
        for (var set = stdFmts.reset(); set = stdFmts.current(); stdFmts.next()) {
            for (var fmt = set[1].reset(); fmt = set[1].current(); set[1].next()) {
                db.addFormat(glsFboUtil.formatKeyInfo(fmt), set[0]);
            }
        }
    };

    /**
    * @param {glsFboUtil.FormatDB} db
    * @param {glsFboUtil.Range} extFmts
    * @param {WebGLRenderingContextBase=} gl
    * @throws {Error}
    */
    glsFboUtil.addExtFormats = function(db, extFmts, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
        var extensions = gl.getSupportedExtensions();

        // loop through the range, looking at the extentions.
        for (var ext = extFmts.reset(); ext = extFmts.current(); extFmts.next()) {
            var tokens = ext.extensions.split(/\s+/);

            var supported = function() {
                for (var i = 0, l = tokens.length; i < l; ++i)
                    if (extensions.indexOf(tokens[i]) === -1) return false;
                return true;
            }();

            if (supported) {
                for (var format = ext.formats.reset(); format = ext.formats.current(); ext.formats.next()) {
                    db.addFormat(glsFboUtil.formatKeyInfo(format), ext.flags);
                }
            }

        }

    };

    /**
    * @param {number} glenum
    * @param {WebGLRenderingContextBase=} gl
    * @return {number}
    * @throws {Error}
    */
    glsFboUtil.formatFlag = function(glenum, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

        switch (glenum) {
         case gl.NONE:
            return glsFboUtil.FormatFlags.ANY_FORMAT;
         case gl.RENDERBUFFER:
            return glsFboUtil.FormatFlags.RENDERBUFFER_VALID;
         case gl.TEXTURE:
            return glsFboUtil.FormatFlags.TEXTURE_VALID;
         case gl.STENCIL_ATTACHMENT:
            return glsFboUtil.FormatFlags.STENCIL_RENDERABLE;
         case gl.DEPTH_ATTACHMENT:
            return glsFboUtil.FormatFlags.DEPTH_RENDERABLE;
         default:
            if (glenum < gl.COLOR_ATTACHMENT0 || glenum > gl.COLOR_ATTACHMENT15) {
                throw new Error('glenum out of range');
            }
        }
        return glsFboUtil.FormatFlags.COLOR_RENDERABLE;
    };

    /**
    * Remove value from array
    * @param {Array} array
    * @param {number} value
    */
    glsFboUtil.remove_from_array = function(array, value) {
        var index = 0;
        while ((index = array.indexOf(value)) != -1) {
            array.splice(index, 1);
        }
    };

    /**
     * glsFboUtil.FormatExtEntry
     * @constructor
     * @struct
     * @param {string=} extensions
     * @param {number=} flags
     * @param {glsFboUtil.Range=} formats
     */
    glsFboUtil.FormatExtEntry = function(extensions, flags, formats) {
        this.extensions = null;
        this.flags = null;
        this.formats = null;

        if (extensions !== undefined) {
            this.extensions = extensions;
            if (flags !== undefined) {
                this.flags = flags;
                if (formats !== undefined)
                    this.formats = formats;
            }
        }

    };

    /**
     * glsFboUtil.Range
     * @constructor
     * @struct
     * @template T
     * @param {Array<T>} array
     * @param {number=} begin
     * @param {number=} end
     */
    glsFboUtil.Range = function(array, begin, end) {
        // @private
        this.m_begin = (begin === undefined ? 0 : begin);
        // @private
        this.m_end = end || array.length;
        /**
        * @private
        * @type {Array<T>}
        */
        this.m_array = array;
        // @private
        this.m_index = this.m_begin;
    };

    /**
    * @return {Array<T>}
    */
    glsFboUtil.Range.prototype.array = function() {
        return this.m_array;
    };

    /**
    * @return {number}
    */
    glsFboUtil.Range.prototype.begin = function() {
        return this.m_begin;
    };

    /**  *generated by script*
    * @return {number}
    */
    glsFboUtil.Range.prototype.end = function() {
        return this.m_end;
    };

    /**
    * Returns the current pointer index as well as the current object
    * @param {number} id
    * @return {{first: number, second: T}}
    */
    glsFboUtil.Range.prototype.get = function(id) {
        return {
            first: id,
            second: this.m_array[id]
        };
    };

    /**
    * Sets the internal pointer to the beginning of the range, and returns the first object.
    * @return {T}
    */
    glsFboUtil.Range.prototype.reset = function() {
        this.m_index = this.m_begin;
        return this.current();
    };

    /**
    * returns the current object within the specified range. The internal pointer is unaltered.
    * @return {T}
    */
    glsFboUtil.Range.prototype.current = function() {
        return this.m_index < this.m_end ? this.m_array[this.m_index] : null;
    };

    /**
    * Increments the internal pointer
    */
    glsFboUtil.Range.prototype.next = function() {
        ++this.m_index;
    };

    /**
     * glsFboUtil.rangeArray
     * replaces the macro GLS_ARRAY_RANGE
     * Creates a new Range object from the specified array, spanning the whole array.
     * @template T
     * @param {Array<T>} array
     * @return {glsFboUtil.Range<T>}
     */
    glsFboUtil.rangeArray = function(array) {
        return new glsFboUtil.Range(array);
    };

    /**
    * @constructor
    * @struct
    * @param {number=} format
    * @param {number=} unsizedType
    */
    glsFboUtil.ImageFormat = function(format, unsizedType) {
        this.format = format || 0;
        //! Type if format is unsized, gl.NONE if sized.
        this.unsizedType = unsizedType || 0;

    };

    /**
    * @param {!glsFboUtil.ImageFormat} obj1
    * @param {!glsFboUtil.ImageFormat} obj2
    * @return {boolean}
    */
    glsFboUtil.ImageFormat.lessthan = function(obj1, obj2) {
        return (
            (obj1.format < obj2.format) ||
            (obj1.format == obj2.format && obj1.unsizedType < obj2.unsizedType)
        );
    };

    /**
    * Sets the object's parameters to gl.NONE
    */
    glsFboUtil.ImageFormat.prototype.none = function() {
        this.format = 0;
        this.unsizedType = 0;
    };

    /**
    * @return {glsFboUtil.ImageFormat}
    */
    glsFboUtil.ImageFormat.none = function() {
        var obj = new glsFboUtil.ImageFormat();
        obj.none();
        return obj;
    };

    // where key is a FormatKey, and a FormatKey is a unsigned 32bit int.

    /**
    * @param {number} key
    * @return {glsFboUtil.ImageFormat}
    */
    glsFboUtil.formatKeyInfo = function(key) {
        return new glsFboUtil.ImageFormat(
            (key & 0x0000ffff),
            (key & 0xffff0000) >>> 16
        );
    };

    /**
     * glsFboUtil.Config Class.
     * @constructor
     */
    glsFboUtil.Config = function() {
        this.type = glsFboUtil.Config.s_types.CONFIG;
        this.target = glsFboUtil.Config.s_target.NONE;
    };
    /**
     * @enum {number}
     */
    glsFboUtil.Config.s_target = {
        NONE: 0,
        RENDERBUFFER: 0x8D41,
        TEXTURE_2D: 0x0DE1,
        TEXTURE_CUBE_MAP: 0x8513,
        TEXTURE_3D: 0x806F,
        TEXTURE_2D_ARRAY: 0x8C1A,

        FRAMEBUFFER: 0x8D40
    };

    // the c++ uses dynamic casts to determain if an object inherits from a
    // given class. Here, each class' constructor assigns a bit to obj.type.
    // look for the bit to see if an object inherits that class.

    /**
    * @enum
    */
    glsFboUtil.Config.s_types = {
        CONFIG: 0x000001,

        IMAGE: 0x000010,
        RENDERBUFFER: 0x000020,
        TEXTURE: 0x000040,
        TEXTURE_FLAT: 0x000080,
        TEXTURE_2D: 0x000100,
        TEXTURE_CUBE_MAP: 0x000200,
        TEXTURE_LAYERED: 0x000400,
        TEXTURE_3D: 0x000800,
        TEXTURE_2D_ARRAY: 0x001000,

        ATTACHMENT: 0x010000,
        ATT_RENDERBUFFER: 0x020000,
        ATT_TEXTURE: 0x040000,
        ATT_TEXTURE_FLAT: 0x080000,
        ATT_TEXTURE_LAYER: 0x100000,

        UNUSED: 0xFFE0E00E
    };

    /**
     * glsFboUtil.Image Class.
     * @constructor
     * @extends {glsFboUtil.Config}
     */
    glsFboUtil.Image = function() {
        glsFboUtil.Config.call(this);
        this.type |= glsFboUtil.Config.s_types.IMAGE;
        this.width = 0;
        this.height = 0;
        this.internalFormat = new glsFboUtil.ImageFormat();
    };

    /**
     * glsFboUtil.Renderbuffer Class.
     * @constructor
     * @extends {glsFboUtil.Image}
     */
    glsFboUtil.Renderbuffer = function() {
        glsFboUtil.Image.call(this);
        this.type |= glsFboUtil.Config.s_types.RENDERBUFFER;
        this.target = glsFboUtil.Config.s_target.RENDERBUFFER;
        this.numSamples = 0;
    };

    /**
     * glsFboUtil.Texture Class.
     * @constructor
     * @extends {glsFboUtil.Image}
     */
    glsFboUtil.Texture = function() {
        glsFboUtil.Image.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE;
        this.numLevels = 1;
    };

    /**
     * glsFboUtil.TextureFlat Class.
     * @constructor
     * @extends {glsFboUtil.Texture}
     */
    glsFboUtil.TextureFlat = function() {
        glsFboUtil.Texture.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE_FLAT;
    };

    /**
     * glsFboUtil.Texture2D Class.
     * @constructor
     * @extends {glsFboUtil.TextureFlat}
     */
    glsFboUtil.Texture2D = function() {
        glsFboUtil.TextureFlat.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE_2D;
        this.target = glsFboUtil.Config.s_target.TEXTURE_2D;
    };

    /**
     * glsFboUtil.TextureCubeMap Class.
     * @constructor
     * @extends {glsFboUtil.TextureFlat}
     */
    glsFboUtil.TextureCubeMap = function() {
        glsFboUtil.TextureFlat.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP;
        this.target = glsFboUtil.Config.s_target.TEXTURE_CUBE_MAP;
    };

    /**
     * glsFboUtil.TextureLayered Class.
     * @constructor
     * @extends {glsFboUtil.Texture}
     */
    glsFboUtil.TextureLayered = function() {
        glsFboUtil.Texture.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE_LAYERED;
        this.numLayers = 1;
    };

    /**
     * glsFboUtil.Texture3D Class.
     * @constructor
     * @extends {glsFboUtil.TextureLayered}
     */
    glsFboUtil.Texture3D = function() {
        glsFboUtil.TextureLayered.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE_3D;
        this.target = glsFboUtil.Config.s_target.TEXTURE_3D;
    };

    /**
     * glsFboUtil.Texture2DArray Class.
     * @constructor
     * @extends {glsFboUtil.TextureLayered}
     */
    glsFboUtil.Texture2DArray = function() {
        glsFboUtil.TextureLayered.call(this);
        this.type |= glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY;
        this.target = glsFboUtil.Config.s_target.TEXTURE_2D_ARRAY;
    };

    /**
     * glsFboUtil.Attachment Class.
     * @constructor
     * @extends {glsFboUtil.Config}
     */
    glsFboUtil.Attachment = function() {
        glsFboUtil.Config.call(this);

        this.type |= glsFboUtil.Config.s_types.ATTACHMENT;

        /** @type {glsFboUtil.Config.s_target} */
        this.target = glsFboUtil.Config.s_target.FRAMEBUFFER;

        /** @type {WebGLObject} */
        this.imageName = null;
    };

    /**
    * this function is declared, but has no definition/is unused in the c++
    * @param {number} attPoint
    * @param {number} image
    * @param {number} vfr
    */
    glsFboUtil.Attachment.prototype.isComplete = function(attPoint, image, vfr) { };

    /**
     * glsFboUtil.RenderBufferAttachments Class.
     * @constructor
     * @extends {glsFboUtil.Attachment}
     */
    glsFboUtil.RenderbufferAttachment = function() {
        glsFboUtil.Attachment.call(this);
        this.type |= glsFboUtil.Config.s_types.ATT_RENDERBUFFER;
        this.renderbufferTarget = glsFboUtil.Config.s_target.RENDERBUFFER;
    };
    glsFboUtil.RenderbufferAttachment.prototype = Object.create(glsFboUtil.Attachment.prototype);
    glsFboUtil.RenderbufferAttachment.prototype.constructor = glsFboUtil.RenderbufferAttachment;

    /**
     * glsFboUtil.TextureAttachment Class.
     * @constructor
     * @extends {glsFboUtil.Attachment}
     */
    glsFboUtil.TextureAttachment = function() {
        glsFboUtil.Attachment.call(this);
        this.type |= glsFboUtil.Config.s_types.ATT_TEXTURE;
        this.level = 0;
    };
    glsFboUtil.TextureAttachment.prototype = Object.create(glsFboUtil.Attachment.prototype);
    glsFboUtil.TextureAttachment.prototype.constructor = glsFboUtil.TextureAttachment;

    /**
     * glsFboUtil.TextureFlatAttachment Class.
     * @constructor
     * @extends {glsFboUtil.TextureAttachment}
     */
    glsFboUtil.TextureFlatAttachment = function() {
        glsFboUtil.TextureAttachment.call(this);
        this.type |= glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT;
        this.texTarget = glsFboUtil.Config.s_target.NONE;
    };
    glsFboUtil.TextureFlatAttachment.prototype = Object.create(glsFboUtil.TextureAttachment.prototype);
    glsFboUtil.TextureFlatAttachment.prototype.constructor = glsFboUtil.TextureFlatAttachment;

    /**
     * glsFboUtil.TextureLayerAttachment Class.
     * @constructor
     * @extends {glsFboUtil.TextureAttachment}
     */
    glsFboUtil.TextureLayerAttachment = function() {
        glsFboUtil.TextureAttachment.call(this);
        this.type |= glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER;
        this.layer = 0;
    };
    glsFboUtil.TextureLayerAttachment.prototype = Object.create(glsFboUtil.TextureAttachment.prototype);
    glsFboUtil.TextureLayerAttachment.prototype.constructor = glsFboUtil.TextureLayerAttachment;

    // these are a collection of helper functions for creating various gl textures.
    glsFboUtil.glsup = function() {

        var glInit = function(cfg, gl) {
            if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_2D) != 0) {
                glInitFlat(cfg, glTarget(cfg, gl), gl);

            } else if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP) != 0) {
                for (var i = gl.TEXTURE_CUBE_MAP_NEGATIVE_X; i <= gl.TEXTURE_CUBE_MAP_POSITIVE_Z; ++i)
                    glInitFlat(cfg, i, gl);
            } else if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_3D) != 0) {
                glInitLayered(cfg, 2, gl);

            } else if ((cfg.type & glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY) != 0) {
                glInitLayered(cfg, 1, gl);
            }
        };

        var glInitFlat = function(cfg, target, gl) {
            var format = glsFboUtil.transferImageFormat(cfg.internalFormat, gl);
            var w = cfg.width;
            var h = cfg.height;
            for (var level = 0; level < cfg.numLevels; ++level) {
                gl.texImage2D(
                    target, level, cfg.internalFormat.format,
                    w, h, 0, format.format, format.dataType, null
                );
                w = Math.max(1, w / 2);
                h = Math.max(1, h / 2);
            }
        };

        var glInitLayered = function(cfg, depth_divider, gl) {
            var format = glsFboUtil.transferImageFormat(cfg.internalFormat, gl);
            var w = cfg.width;
            var h = cfg.height;
            var depth = cfg.numLayers;
            for (var level = 0; level < cfg.numLevels; ++level) {
                gl.texImage3D(
                    glTarget(cfg, gl), level, cfg.internalFormat.format,
                    w, h, depth, 0, format.format, format.dataType, null
                );
                w = Math.max(1, w / 2);
                h = Math.max(1, h / 2);
                depth = Math.max(1, depth / depth_divider);
            }
        };

        var glCreate = function(cfg, gl) {
            if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

            if (cfg.type & glsFboUtil.Config.s_types.RENDERBUFFER) {
                var ret = gl.createRenderbuffer();
                gl.bindRenderbuffer(gl.RENDERBUFFER, ret);

                if (cfg.numSamples == 0) {
                    gl.renderbufferStorage(
                        gl.RENDERBUFFER,
                        cfg.internalFormat.format,
                        cfg.width, cfg.height
                    );
                } else {
                    gl.renderbufferStorageMultisample(
                        gl.RENDERBUFFER,
                        cfg.numSamples,
                        cfg.internalFormat.format,
                        cfg.width, cfg.height
                    );
                }
                gl.bindRenderbuffer(gl.RENDERBUFFER, null);

            } else if (cfg.type & glsFboUtil.Config.s_types.TEXTURE) {
                var ret = gl.createTexture();
                gl.bindTexture(glTarget(cfg, gl), ret);
                glInit(cfg, gl);
                gl.bindTexture(glTarget(cfg, gl), null);

            } else {
                throw new Error('Impossible image type');
            }
            return ret;
        };

        var glTarget = function(cfg, gl) {
            if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
            var mask = (
                glsFboUtil.Config.s_types.RENDERBUFFER |
                glsFboUtil.Config.s_types.TEXTURE_2D |
                glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP |
                glsFboUtil.Config.s_types.TEXTURE_3D |
                glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY
            );
            switch (cfg.type & mask) {
                case glsFboUtil.Config.s_types.RENDERBUFFER: return gl.RENDERBUFFER;
                case glsFboUtil.Config.s_types.TEXTURE_2D: return gl.TEXTURE_2D;
                case glsFboUtil.Config.s_types.TEXTURE_CUBE_MAP: return gl.TEXTURE_CUBE_MAP;
                case glsFboUtil.Config.s_types.TEXTURE_3D: return gl.TEXTURE_3D;
                case glsFboUtil.Config.s_types.TEXTURE_2D_ARRAY: return gl.TEXTURE_2D_ARRAY;
                default: break;
            }
            throw new Error('Impossible image type.');
        };

        var glDelete = function(cfg, img, gl) {
            if (cfg.type & glsFboUtil.Config.s_types.RENDERBUFFER)
                gl.deleteRenderbuffer(img);
            else if (cfg.type & glsFboUtil.Config.s_types.TEXTURE)
                gl.deleteTexture(img);
            else
                throw new Error('Impossible image type');
        };

        return {
            create: glCreate,
            remove: glDelete
        };

    }();

    /**  *generated by script*
    * @param {number} img
    * @return {number}
    */
    glsFboUtil.imageNumSamples = function(img) {
        return (img.numSamples != undefined) ? img.numSamples : 0;
    };

    /**  *generated by script*
    * @param {glsFboUtil.Attachment} att
    * @param {number} attPoint
    * @param {WebGLRenderingContextBase=} gl
    * @throws {Error}
    */
    glsFboUtil.attachAttachment = function(att, attPoint, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

        var mask = (
            glsFboUtil.Config.s_types.ATT_RENDERBUFFER |
            glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT |
            glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER
        );

        switch (att.type & mask) {
            case glsFboUtil.Config.s_types.ATT_RENDERBUFFER:
                gl.framebufferRenderbuffer(
                    att.target, attPoint, att.renderbufferTarget, /** @type {WebGLRenderbuffer} */(att.imageName)
                );
                break;
            case glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT:
                gl.framebufferTexture2D(
                    att.target, attPoint, att.texTarget, /** @type {WebGLTexture} */(att.imageName), att.level
                );
                break;
            case glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER:
                gl.framebufferTextureLayer(
                    att.target, attPoint, /** @type {WebGLTexture} */(att.imageName), att.level, att.layer
                );
                break;
            default:
                throw new Error('Impossible attachment type');
        }

    };

    /**  *generated by script*
    * @param {glsFboUtil.Attachment} att
    * @param {WebGLRenderingContextBase=} gl
    * @return {number}
    * @throws {Error}
    */
    glsFboUtil.attachmentType = function(att, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

        if (att.type & glsFboUtil.Config.s_types.ATT_RENDERBUFFER) {
            return gl.RENDERBUFFER;
        }
        if (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE) {
            return gl.TEXTURE;
        }
        throw new Error('Impossible attachment type.');

    };

    /**
    * @param {glsFboUtil.Attachment} att
    * @return {number}
    * @throws {Error}
    */
    glsFboUtil.textureLayer = function(att) {
        if (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE_FLAT) return 0;
        if (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE_LAYER) return att.layer;
        throw new Error('Impossible attachment type.');
    };

    /**
    * @param {glsFboUtil.Checker} cctx
    * @param {glsFboUtil.Attachment} att
    * @param {number} attPoint
    * @param {glsFboUtil.Image} image
    * @param {glsFboUtil.FormatDB} db
    * @param {WebGLRenderingContextBase=} gl
    * @throws {Error}
    */
    glsFboUtil.checkAttachmentCompleteness = function(cctx, att, attPoint, image, db, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

        // GLES2 4.4.5 / GLES3 4.4.4, "glsFboUtil.Framebuffer attachment completeness"
        if (
            (att.type & glsFboUtil.Config.s_types.ATT_TEXTURE) &&
            (image.type & glsFboUtil.Config.s_types.TEXTURE_LAYERED)
        ) {
            // GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is
            // TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a
            // three-dimensional texture, then the value of
            // FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the depth
            // of the texture.
            //
            // GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is
            // TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a
            // two-dimensional array texture, then the value of
            // FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the
            // number of layers in the texture.
            cctx.addFBOStatus(
                glsFboUtil.textureLayer(att) < image.numLayers,
                gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
            );
        }

        // "The width and height of image are non-zero."
        cctx.addFBOStatus(
            image.width > 0 && image.height > 0,
            gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
        );

        // Check for renderability
        var flags = db.getFormatInfo(image.internalFormat, glsFboUtil.FormatFlags.ANY_FORMAT);

        // If the format does not have the proper renderability flag, the
        // completeness check _must_ fail.
        cctx.addFBOStatus(
            (flags & glsFboUtil.formatFlag(attPoint)) != 0,
            gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
        );

        // If the format is only optionally renderable, the completeness check _can_ fail.
        cctx.addPotentialFBOStatus(
            (flags & glsFboUtil.FormatFlags.REQUIRED_RENDERABLE) != 0,
            gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
        );

    };

    // replaces GLS_UNSIZED_FORMATKEY

    /**
    * All params and return types for this function are 32 bit
    * @param {number} format
    * @param {number} type
    * @return {number}
    */
    glsFboUtil.formatkey = function(format, type) {
        // The formatkey value should be 32-bit unsigned int.
        return ((type << 16) >>> 0 | format) & 0xFFFFFFFF;
    };

    /**
    * @enum
    */
    glsFboUtil.FormatFlags = {
        ANY_FORMAT: 0x00,
        COLOR_RENDERABLE: 0x01,
        DEPTH_RENDERABLE: 0x02,
        STENCIL_RENDERABLE: 0x04,
        RENDERBUFFER_VALID: 0x08,
        TEXTURE_VALID: 0x10,
        REQUIRED_RENDERABLE: 0x20 //< Without this, renderability is allowed, not required.
    };

    /**
    * A framebuffer configuration
    * @constructor
    * @param {WebGLRenderingContextBase=} gl
    */
    glsFboUtil.Framebuffer = function(gl) {
        this.m_gl = gl || window.gl;
        this.fbid = 0;

        var fbidCompare = function(obj1, obj2) {
            return obj1._fbid < obj2._fbid;
        };

        this.attachments = /** @type {glsFboUtil.Map<number,glsFboUtil.Attachment>} */(
            new glsFboUtil.Map(glsFboUtil.Map.compareNumber)
        );
        this.textures = /** @type {glsFboUtil.Map<Object,glsFboUtil.Texture>} */(
            new glsFboUtil.Map(fbidCompare)
        );
        this.rbos = /** @type {glsFboUtil.Map<Object,glsFboUtil.Renderbuffer>} */(
            new glsFboUtil.Map(fbidCompare)
        );
    };

    /**
    * @param {number} attPoint
    * @param {glsFboUtil.Attachment} att
    */
    glsFboUtil.Framebuffer.prototype.attach = function(attPoint, att) {
        if (!att) {
            this.attachments.remove(attPoint);
        } else {
            this.attachments.set(attPoint, att);
        }
    };

    /**
    * @param {WebGLTexture} texName
    * @param {glsFboUtil.Texture} texCfg
    */
    glsFboUtil.Framebuffer.prototype.setTexture = function(texName, texCfg) {
        texName._fbid = this.fbid++;
        this.textures.set(texName, texCfg);
    };

    /**
    * @param {WebGLRenderbuffer} rbName
    * @param {glsFboUtil.Renderbuffer} rbCfg
    */
    glsFboUtil.Framebuffer.prototype.setRbo = function(rbName, rbCfg) {
        rbName._fbid = this.fbid++;
        this.rbos.set(rbName, rbCfg);
    };

    /**
    * @param {number} type
    * @param {WebGLObject} imgName
    * @return {glsFboUtil.Image}
    * @throws {Error}
    */
    glsFboUtil.Framebuffer.prototype.getImage = function(type, imgName) {
        switch (type) {
            case this.m_gl.TEXTURE: return this.textures.lookupDefault(/** @type {WebGLTexture} */(imgName), null);
            case this.m_gl.RENDERBUFFER: return this.rbos.lookupDefault(/** @type {WebGLTexture} */(imgName), null);
            default: break;
        }
        throw new Error('Bad image type.');
    };

    /**
    * @constructor
    * @extends {glsFboUtil.Framebuffer}
    * @param {WebGLFramebuffer} fbo
    * @param {number} target
    * @param {WebGLRenderingContextBase=} gl
    */
    glsFboUtil.FboBuilder = function(fbo, target, gl) {
        glsFboUtil.Framebuffer.call(this, gl);

        this.m_gl = gl || window.gl;
        this.m_target = target;
        this.m_configs = [];
        this.m_error = this.m_gl.NO_ERROR;

        this.m_gl.bindFramebuffer(this.m_target, fbo);

    };

    glsFboUtil.FboBuilder.prototype = Object.create(glsFboUtil.Framebuffer.prototype);
    glsFboUtil.FboBuilder.prototype.constructor = glsFboUtil.FboBuilder;

    glsFboUtil.FboBuilder.prototype.deinit = function() {

        var pair;
        for (var i = 0; i < this.textures.length; ++i) {
            pair = this.textures.getIndex(i);
            glsFboUtil.glsup.remove(pair.second, pair.first, this.m_gl);
        }
        this.textures.clear();

        for (var i = 0; i < this.rbos.length; ++i) {
            pair = this.rbos.getIndex(i);
            glsFboUtil.glsup.remove(pair.second, pair.first, this.m_gl);
        }
        this.rbos.clear();

        this.m_gl.bindFramebuffer(this.m_target, null);
/*
        for (var i = 0 ; i < this.m_configs.length ; ++i) {
            delete this.m_configs[i];
        }
//*/
    };

    /**
    * @param {number} attPoint
    * @param {glsFboUtil.Attachment} att
    */
    glsFboUtil.FboBuilder.prototype.glAttach = function(attPoint, att) {
        if (!att) {
            this.m_gl.framebufferRenderbuffer(this.m_target, attPoint, this.m_gl.RENDERBUFFER, null);
        } else {
            glsFboUtil.attachAttachment(att, attPoint, this.m_gl);
        }
        this.checkError();
        this.attach(attPoint, att);
    };

    /**
    * @param {glsFboUtil.Texture} texCfg
    * @return {WebGLTexture}
    */
    glsFboUtil.FboBuilder.prototype.glCreateTexture = function(texCfg) {
        var texName = glsFboUtil.glsup.create(texCfg, this.m_gl);
        this.checkError();
        this.setTexture(texName, texCfg);
        return texName;
    };

    /**  *generated by script*
    * @param {glsFboUtil.Renderbuffer} rbCfg
    * @return {WebGLRenderbuffer}
    */
    glsFboUtil.FboBuilder.prototype.glCreateRbo = function(rbCfg) {
        var rbName = glsFboUtil.glsup.create(rbCfg, this.m_gl);
        this.checkError();
        this.setRbo(rbName, rbCfg);
        return rbName;
    };

    /**
    * @param {function(new:glsFboUtil.Config)} Definition
    * @return {glsFboUtil.Config}
    */
    glsFboUtil.FboBuilder.prototype.makeConfig = function(Definition) {
        var cfg = new Definition();
        this.m_configs.push(cfg);
        return cfg;
    };

    /**
    */
    glsFboUtil.FboBuilder.prototype.checkError = function() {
        var error = this.m_gl.getError();
        if (error != this.m_gl.NO_ERROR && this.m_error == this.m_gl.NO_ERROR) {
            this.m_error = error;
        }
    };

    /**  *generated by script*
    * @return {number}
    */
    glsFboUtil.FboBuilder.prototype.getError = function() {
        return this.m_error;
    };

    glsFboUtil.isFramebufferStatus = function(fboStatus) {
        return gluStrUtil.getFramebufferStatusName(fboStatus) != '';
    }

    glsFboUtil.isErrorCode = function(errorCode) {
        return gluStrUtil.getErrorName(errorCode) != '';
    }

    /**
    * @typedef {funcion(): glsFboUtil.ValidStatusCodes}
    */
    glsFboUtil.ValidStatusCodes = function() {
        this.m_errorCodes = [];
        this.m_errorStatusCodes = [];
        this.m_allowComplete = false;
    };

    glsFboUtil.ValidStatusCodes.prototype.isFBOStatusValid = function(fboStatus) {
        if (fboStatus == gl.FRAMEBUFFER_COMPLETE)
            return this.m_allowComplete;
        else {
            for(var ndx = 0; ndx < this.m_errorStatusCodes.length; ++ndx) {
                if (this.m_errorStatusCodes[ndx] == fboStatus)
                    return true;
            }
            return false;
        }
    };

    glsFboUtil.ValidStatusCodes.prototype.isFBOStatusRequired = function(fboStatus) {
        if (fboStatus == gl.FRAMEBUFFER_COMPLETE)
            return this.m_allowComplete && this.m_errorStatusCodes.length == 0;
        else
            // fboStatus is the only allowed error status and succeeding is forbidden
            return !this.m_allowComplete && this.m_errorStatusCodes.length == 1 && this.m_errorStatusCodes[0] == fboStatus;
    };

    glsFboUtil.ValidStatusCodes.prototype.isErrorCodeValid = function(errorCode) {
        if (errorCode == gl.NO_ERROR)
            return this.m_errorCodes.length == 0;
        else {
            // rule violation exists?
            for (var ndx = 0; ndx < this.m_errorCodes.length; ++ndx) {
                if (this.m_errorCodes[ndx] == errorCode)
                    return true;
            }
            return false;
        }
    };

    glsFboUtil.ValidStatusCodes.prototype.isErrorCodeRequired = function(errorCode) {
        if (this.m_errorCodes.length == 0 && errorCode == gl.NO_ERROR)
            return true;
        else
            // only this error code listed
            return this.m_errorCodes.length == 1 && merrorCodes[0] == errorCode;
    };

    glsFboUtil.ValidStatusCodes.prototype.addErrorCode = function(error) {
        DE_ASSERT(glsFboUtil.isErrorCode(error));
        DE_ASSERT(error != gl.NO_ERROR)
        this.m_errorCodes.push(error);
    };

    glsFboUtil.ValidStatusCodes.prototype.addFBOErrorStatus = function(status) {
        DE_ASSERT(glsFboUtil.isFramebufferStatus(status));
        DE_ASSERT(status != gl.FRAMEBUFFER_COMPLETE)
        this.m_errorStatusCodes.push(status);
    };

    glsFboUtil.ValidStatusCodes.prototype.setAllowComplete = function(b) {
        this.m_allowComplete = b;
    };

    /**
    * @typedef {function(): glsFboUtil.Checker}
    */
    glsFboUtil.CheckerFactory;

    /**
    * @constructor
    * @param {WebGLRenderingContextBase=} gl
    * @throws {Error}
    */
    glsFboUtil.Checker = function(gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

        this.m_statusCodes = new glsFboUtil.ValidStatusCodes();
        this.m_statusCodes.setAllowComplete(true);

        if (typeof(this.check) != 'function')
            throw new Error('Constructor called on virtual class: glsFboUtil.Checker');
    };

    /**
    * @param {boolean} condition
    * @param {number} error
    */
    glsFboUtil.Checker.prototype.addGLError = function(condition, error) {
        if (!condition) {
            this.m_statusCodes.addErrorCode(error);
            this.m_statusCodes.setAllowComplete(false);
        }
    };

    /**
    * @param {boolean} condition
    * @param {number} error
    */
    glsFboUtil.Checker.prototype.addPotentialGLError = function(condition, error) {
        if (!condition) {
            this.m_statusCodes.addErrorCode(error);
        }
    };

    /**
    * @param {boolean} condition
    * @param {number} status
    */
    glsFboUtil.Checker.prototype.addFBOStatus = function(condition, status) {
        if (!condition) {
            this.m_statusCodes.addFBOErrorStatus(status);
            this.m_statusCodes.setAllowComplete(false);
        }
    };

    /**
    * @param {boolean} condition
    * @param {number} status
    */
    glsFboUtil.Checker.prototype.addPotentialFBOStatus = function(condition, status) {
        if (!condition) {
            this.m_statusCodes.addFBOErrorStatus(status);
        }
    };

    /**
    * @return {Array<number>}
    */
    glsFboUtil.Checker.prototype.getStatusCodes = function () {
        return this.m_statusCodes;
    };

    /**
    * @param {glsFboUtil.ImageFormat} imgFormat
    * @param {WebGLRenderingContextBase=} gl
    * @return {gluTextureUtil.TransferFormat}
    * @throws {Error}
    */
    glsFboUtil.transferImageFormat = function(imgFormat, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');
        if (imgFormat.unsizedType == gl.NONE)
            return gluTextureUtil.getTransferFormat(gluTextureUtil.mapGLInternalFormat(imgFormat.format));
        else
            return new gluTextureUtil.TransferFormat(imgFormat.format, imgFormat.unsizedType);
    };

    // FormatDB, CheckerFactory

    /**
    * @constructor
    * @param {glsFboUtil.FormatDB} formats
    * @param {glsFboUtil.CheckerFactory} factory
    */
    glsFboUtil.FboVerifier = function(formats, factory) {
        this.m_formats = formats;
        this.m_factory = factory;
    };
    // config::Framebuffer
    glsFboUtil.FboVerifier.prototype.validStatusCodes = function(cfg, gl) {
        if (!(gl = gl || window.gl)) throw new Error('Invalid gl object');

        /** @type {glsFboUtil.Checker} */
        var cctx = this.m_factory();

        for (var id = 0; id < cfg.textures.length; ++id) {
            var flags = this.m_formats.getFormatInfo(cfg.textures.getIndex(id).second.internalFormat, glsFboUtil.FormatFlags.ANY_FORMAT);
            var textureIsValid = (flags & glsFboUtil.FormatFlags.TEXTURE_VALID) != 0;
            cctx.addGLError(textureIsValid, gl.INVALID_ENUM);
            cctx.addGLError(textureIsValid, gl.INVALID_OPERATION);
            cctx.addGLError(textureIsValid, gl.INVALID_VALUE);
        }

        for (var id = 0; id < cfg.rbos.length; ++id) {
            var flags = this.m_formats.getFormatInfo(cfg.rbos.getIndex(id).second.internalFormat, glsFboUtil.FormatFlags.ANY_FORMAT);
            var rboIsValid = (flags & glsFboUtil.FormatFlags.RENDERBUFFER_VALID) != 0;
            cctx.addGLError(rboIsValid, gl.INVALID_ENUM);
        }

        var count = 0;
        for (var index = 0; index < cfg.attachments.length; ++index) {
            var attPoint = cfg.attachments.getIndex(index).first;
            var att = cfg.attachments.getIndex(index).second;
            /** @type {glsFboUtil.Image}*/
            var image = cfg.getImage(glsFboUtil.attachmentType(att, gl), att.imageName);
            glsFboUtil.checkAttachmentCompleteness(cctx, att, attPoint, image, this.m_formats, gl);
            cctx.check(attPoint, att, image);
            ++count;
        }

        // "There is at least one image attached to the framebuffer."
        // TODO: support XXX_framebuffer_no_attachments
        cctx.addFBOStatus(count > 0, gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);

        return cctx.getStatusCodes();

    };

});