| /*------------------------------------------------------------------------- |
| * 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(); |
| |
| }; |
| |
| }); |
