@codexo/exojs 0.4.0

package/dist/esm/vendor/webgl-debug.js

@@ -0,0 +1,1160 @@
+/*
+** Copyright (c) 2012 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+// Various functions for helping debug WebGL apps.
+
+const WebGLDebugUtils = function() {
+
+    /**
+     * Wrapped logging function.
+     * @param {string} msg Message to log.
+     */
+    var log = function(msg) {
+        if (window.console && window.console.log) {
+            window.console.log(msg);
+        }
+    };
+
+    /**
+     * Wrapped error logging function.
+     * @param {string} msg Message to log.
+     */
+    var error = function(msg) {
+        if (window.console && window.console.error) {
+            window.console.error(msg);
+        } else {
+            log(msg);
+        }
+    };
+
+
+    /**
+     * Which arguments are enums based on the number of arguments to the function.
+     * So
+     *    'texImage2D': {
+     *       9: { 0:true, 2:true, 6:true, 7:true },
+     *       6: { 0:true, 2:true, 3:true, 4:true },
+     *    },
+     *
+     * means if there are 9 arguments then 6 and 7 are enums, if there are 6
+     * arguments 3 and 4 are enums
+     *
+     * @type {!Object.<number, !Object.<number, string>}
+     */
+    var glValidEnumContexts = {
+        // Generic setters and getters
+
+        'enable': {1: { 0:true }},
+        'disable': {1: { 0:true }},
+        'getParameter': {1: { 0:true }},
+
+        // Rendering
+
+        'drawArrays': {3:{ 0:true }},
+        'drawElements': {4:{ 0:true, 2:true }},
+
+        // Shaders
+
+        'createShader': {1: { 0:true }},
+        'getShaderParameter': {2: { 1:true }},
+        'getProgramParameter': {2: { 1:true }},
+        'getShaderPrecisionFormat': {2: { 0: true, 1:true }},
+
+        // Vertex attributes
+
+        'getVertexAttrib': {2: { 1:true }},
+        'vertexAttribPointer': {6: { 2:true }},
+
+        // Textures
+
+        'bindTexture': {2: { 0:true }},
+        'activeTexture': {1: { 0:true }},
+        'getTexParameter': {2: { 0:true, 1:true }},
+        'texParameterf': {3: { 0:true, 1:true }},
+        'texParameteri': {3: { 0:true, 1:true, 2:true }},
+        // texImage2D and texSubImage2D are defined below with WebGL 2 entrypoints
+        'copyTexImage2D': {8: { 0:true, 2:true }},
+        'copyTexSubImage2D': {8: { 0:true }},
+        'generateMipmap': {1: { 0:true }},
+        // compressedTexImage2D and compressedTexSubImage2D are defined below with WebGL 2 entrypoints
+
+        // Buffer objects
+
+        'bindBuffer': {2: { 0:true }},
+        // bufferData and bufferSubData are defined below with WebGL 2 entrypoints
+        'getBufferParameter': {2: { 0:true, 1:true }},
+
+        // Renderbuffers and framebuffers
+
+        'pixelStorei': {2: { 0:true, 1:true }},
+        // readPixels is defined below with WebGL 2 entrypoints
+        'bindRenderbuffer': {2: { 0:true }},
+        'bindFramebuffer': {2: { 0:true }},
+        'checkFramebufferStatus': {1: { 0:true }},
+        'framebufferRenderbuffer': {4: { 0:true, 1:true, 2:true }},
+        'framebufferTexture2D': {5: { 0:true, 1:true, 2:true }},
+        'getFramebufferAttachmentParameter': {3: { 0:true, 1:true, 2:true }},
+        'getRenderbufferParameter': {2: { 0:true, 1:true }},
+        'renderbufferStorage': {4: { 0:true, 1:true }},
+
+        // Frame buffer operations (clear, blend, depth test, stencil)
+
+        'clear': {1: { 0: { 'enumBitwiseOr': ['COLOR_BUFFER_BIT', 'DEPTH_BUFFER_BIT', 'STENCIL_BUFFER_BIT'] }}},
+        'depthFunc': {1: { 0:true }},
+        'blendFunc': {2: { 0:true, 1:true }},
+        'blendFuncSeparate': {4: { 0:true, 1:true, 2:true, 3:true }},
+        'blendEquation': {1: { 0:true }},
+        'blendEquationSeparate': {2: { 0:true, 1:true }},
+        'stencilFunc': {3: { 0:true }},
+        'stencilFuncSeparate': {4: { 0:true, 1:true }},
+        'stencilMaskSeparate': {2: { 0:true }},
+        'stencilOp': {3: { 0:true, 1:true, 2:true }},
+        'stencilOpSeparate': {4: { 0:true, 1:true, 2:true, 3:true }},
+
+        // Culling
+
+        'cullFace': {1: { 0:true }},
+        'frontFace': {1: { 0:true }},
+
+        // ANGLE_instanced_arrays extension
+
+        'drawArraysInstancedANGLE': {4: { 0:true }},
+        'drawElementsInstancedANGLE': {5: { 0:true, 2:true }},
+
+        // EXT_blend_minmax extension
+
+        'blendEquationEXT': {1: { 0:true }},
+
+        // WebGL 2 Buffer objects
+
+        'bufferData': {
+            3: { 0:true, 2:true }, // WebGL 1
+            4: { 0:true, 2:true }, // WebGL 2
+            5: { 0:true, 2:true }  // WebGL 2
+        },
+        'bufferSubData': {
+            3: { 0:true }, // WebGL 1
+            4: { 0:true }, // WebGL 2
+            5: { 0:true }  // WebGL 2
+        },
+        'copyBufferSubData': {5: { 0:true, 1:true }},
+        'getBufferSubData': {3: { 0:true }, 4: { 0:true }, 5: { 0:true }},
+
+        // WebGL 2 Framebuffer objects
+
+        'blitFramebuffer': {10: { 8: { 'enumBitwiseOr': ['COLOR_BUFFER_BIT', 'DEPTH_BUFFER_BIT', 'STENCIL_BUFFER_BIT'] }, 9:true }},
+        'framebufferTextureLayer': {5: { 0:true, 1:true }},
+        'invalidateFramebuffer': {2: { 0:true }},
+        'invalidateSubFramebuffer': {6: { 0:true }},
+        'readBuffer': {1: { 0:true }},
+
+        // WebGL 2 Renderbuffer objects
+
+        'getInternalformatParameter': {3: { 0:true, 1:true, 2:true }},
+        'renderbufferStorageMultisample': {5: { 0:true, 2:true }},
+
+        // WebGL 2 Texture objects
+
+        'texStorage2D': {5: { 0:true, 2:true }},
+        'texStorage3D': {6: { 0:true, 2:true }},
+        'texImage2D': {
+            9: { 0:true, 2:true, 6:true, 7:true }, // WebGL 1 & 2
+            6: { 0:true, 2:true, 3:true, 4:true }, // WebGL 1
+            10: { 0:true, 2:true, 6:true, 7:true } // WebGL 2
+        },
+        'texImage3D': {
+            10: { 0:true, 2:true, 7:true, 8:true },
+            11: { 0:true, 2:true, 7:true, 8:true }
+        },
+        'texSubImage2D': {
+            9: { 0:true, 6:true, 7:true }, // WebGL 1 & 2
+            7: { 0:true, 4:true, 5:true }, // WebGL 1
+            10: { 0:true, 6:true, 7:true } // WebGL 2
+        },
+        'texSubImage3D': {
+            11: { 0:true, 8:true, 9:true },
+            12: { 0:true, 8:true, 9:true }
+        },
+        'copyTexSubImage3D': {9: { 0:true }},
+        'compressedTexImage2D': {
+            7: { 0: true, 2:true }, // WebGL 1 & 2
+            8: { 0: true, 2:true }, // WebGL 2
+            9: { 0: true, 2:true }  // WebGL 2
+        },
+        'compressedTexImage3D': {
+            8: { 0: true, 2:true },
+            9: { 0: true, 2:true },
+            10: { 0: true, 2:true }
+        },
+        'compressedTexSubImage2D': {
+            8: { 0: true, 6:true }, // WebGL 1 & 2
+            9: { 0: true, 6:true }, // WebGL 2
+            10: { 0: true, 6:true } // WebGL 2
+        },
+        'compressedTexSubImage3D': {
+            10: { 0: true, 8:true },
+            11: { 0: true, 8:true },
+            12: { 0: true, 8:true }
+        },
+
+        // WebGL 2 Vertex attribs
+
+        'vertexAttribIPointer': {5: { 2:true }},
+
+        // WebGL 2 Writing to the drawing buffer
+
+        'drawArraysInstanced': {4: { 0:true }},
+        'drawElementsInstanced': {5: { 0:true, 2:true }},
+        'drawRangeElements': {6: { 0:true, 4:true }},
+
+        // WebGL 2 Reading back pixels
+
+        'readPixels': {
+            7: { 4:true, 5:true }, // WebGL 1 & 2
+            8: { 4:true, 5:true }  // WebGL 2
+        },
+
+        // WebGL 2 Multiple Render Targets
+
+        'clearBufferfv': {3: { 0:true }, 4: { 0:true }},
+        'clearBufferiv': {3: { 0:true }, 4: { 0:true }},
+        'clearBufferuiv': {3: { 0:true }, 4: { 0:true }},
+        'clearBufferfi': {4: { 0:true }},
+
+        // WebGL 2 Query objects
+
+        'beginQuery': {2: { 0:true }},
+        'endQuery': {1: { 0:true }},
+        'getQuery': {2: { 0:true, 1:true }},
+        'getQueryParameter': {2: { 1:true }},
+
+        // WebGL 2 Sampler objects
+
+        'samplerParameteri': {3: { 1:true, 2:true }},
+        'samplerParameterf': {3: { 1:true }},
+        'getSamplerParameter': {2: { 1:true }},
+
+        // WebGL 2 Sync objects
+
+        'fenceSync': {2: { 0:true, 1: { 'enumBitwiseOr': [] } }},
+        'clientWaitSync': {3: { 1: { 'enumBitwiseOr': ['SYNC_FLUSH_COMMANDS_BIT'] } }},
+        'waitSync': {3: { 1: { 'enumBitwiseOr': [] } }},
+        'getSyncParameter': {2: { 1:true }},
+
+        // WebGL 2 Transform Feedback
+
+        'bindTransformFeedback': {2: { 0:true }},
+        'beginTransformFeedback': {1: { 0:true }},
+        'transformFeedbackVaryings': {3: { 2:true }},
+
+        // WebGL2 Uniform Buffer Objects and Transform Feedback Buffers
+
+        'bindBufferBase': {3: { 0:true }},
+        'bindBufferRange': {5: { 0:true }},
+        'getIndexedParameter': {2: { 0:true }},
+        'getActiveUniforms': {3: { 2:true }},
+        'getActiveUniformBlockParameter': {3: { 2:true }}
+    };
+
+    /**
+     * Map of numbers to names.
+     * @type {Object}
+     */
+    var glEnums = null;
+
+    /**
+     * Map of names to numbers.
+     * @type {Object}
+     */
+    var enumStringToValue = null;
+
+    /**
+     * Initializes this module. Safe to call more than once.
+     * @param {!WebGLRenderingContext} ctx A WebGL context. If
+     *    you have more than one context it doesn't matter which one
+     *    you pass in, it is only used to pull out constants.
+     */
+    function init(ctx) {
+        if (glEnums == null) {
+            glEnums = { };
+            enumStringToValue = { };
+            for (var propertyName in ctx) {
+                if (typeof ctx[propertyName] == 'number') {
+                    glEnums[ctx[propertyName]] = propertyName;
+                    enumStringToValue[propertyName] = ctx[propertyName];
+                }
+            }
+        }
+    }
+
+    /**
+     * Checks the utils have been initialized.
+     */
+    function checkInit() {
+        if (glEnums == null) {
+            throw 'WebGLDebugUtils.init(ctx) not called';
+        }
+    }
+
+    /**
+     * Returns true or false if value matches any WebGL enum
+     * @param {*} value Value to check if it might be an enum.
+     * @return {boolean} True if value matches one of the WebGL defined enums
+     */
+    function mightBeEnum(value) {
+        checkInit();
+        return (glEnums[value] !== undefined);
+    }
+
+    /**
+     * Gets an string version of an WebGL enum.
+     *
+     * Example:
+     *   var str = WebGLDebugUtil.glEnumToString(ctx.getError());
+     *
+     * @param {number} value Value to return an enum for
+     * @return {string} The string version of the enum.
+     */
+    function glEnumToString(value) {
+        checkInit();
+        var name = glEnums[value];
+        return (name !== undefined) ? ("gl." + name) :
+            ("/*UNKNOWN WebGL ENUM*/ 0x" + value.toString(16) + "");
+    }
+
+    /**
+     * Returns the string version of a WebGL argument.
+     * Attempts to convert enum arguments to strings.
+     * @param {string} functionName the name of the WebGL function.
+     * @param {number} numArgs the number of arguments passed to the function.
+     * @param {number} argumentIndx the index of the argument.
+     * @param {*} value The value of the argument.
+     * @return {string} The value as a string.
+     */
+    function glFunctionArgToString(functionName, numArgs, argumentIndex, value) {
+        var funcInfo = glValidEnumContexts[functionName];
+        if (funcInfo !== undefined) {
+            var funcInfo = funcInfo[numArgs];
+            if (funcInfo !== undefined) {
+                if (funcInfo[argumentIndex]) {
+                    if (typeof funcInfo[argumentIndex] === 'object' &&
+                        funcInfo[argumentIndex]['enumBitwiseOr'] !== undefined) {
+                        var enums = funcInfo[argumentIndex]['enumBitwiseOr'];
+                        var orResult = 0;
+                        var orEnums = [];
+                        for (var i = 0; i < enums.length; ++i) {
+                            var enumValue = enumStringToValue[enums[i]];
+                            if ((value & enumValue) !== 0) {
+                                orResult |= enumValue;
+                                orEnums.push(glEnumToString(enumValue));
+                            }
+                        }
+                        if (orResult === value) {
+                            return orEnums.join(' | ');
+                        } else {
+                            return glEnumToString(value);
+                        }
+                    } else {
+                        return glEnumToString(value);
+                    }
+                }
+            }
+        }
+        if (value === null) {
+            return "null";
+        } else if (value === undefined) {
+            return "undefined";
+        } else {
+            return value.toString();
+        }
+    }
+
+    /**
+     * Converts the arguments of a WebGL function to a string.
+     * Attempts to convert enum arguments to strings.
+     *
+     * @param {string} functionName the name of the WebGL function.
+     * @param {Array<*>} args The arguments.
+     * @return {string} The arguments as a string.
+     */
+    function glFunctionArgsToString(functionName, args) {
+        // apparently we can't do args.join(",");
+        var argStr = "";
+        var numArgs = args.length;
+        for (var ii = 0; ii < numArgs; ++ii) {
+            argStr += ((ii == 0) ? '' : ', ') +
+                glFunctionArgToString(functionName, numArgs, ii, args[ii]);
+        }
+        return argStr;
+    }
+
+    function makePropertyWrapper(wrapper, original, propertyName) {
+        //log("wrap prop: " + propertyName);
+        wrapper.__defineGetter__(propertyName, function() {
+            return original[propertyName];
+        });
+        // TODO(gmane): this needs to handle properties that take more than
+        // one value?
+        wrapper.__defineSetter__(propertyName, function(value) {
+            //log("set: " + propertyName);
+            original[propertyName] = value;
+        });
+    }
+
+    /**
+     * Given a WebGL context returns a wrapped context that calls
+     * gl.getError after every command and calls a function if the
+     * result is not gl.NO_ERROR.
+     *
+     * @param {!WebGLRenderingContext} ctx The webgl context to
+     *        wrap.
+     * @param {!function(err, funcName, args): void} opt_onErrorFunc
+     *        The function to call when gl.getError returns an
+     *        error. If not specified the default function calls
+     *        console.log with a message.
+     * @param {!function(funcName, args): void} opt_onFunc The
+     *        function to call when each webgl function is called.
+     *        You can use this to log all calls for example.
+     * @param {!WebGLRenderingContext} opt_err_ctx The webgl context
+     *        to call getError on if different than ctx.
+     */
+    function makeDebugContext(ctx, opt_onErrorFunc, opt_onFunc, opt_err_ctx) {
+        opt_err_ctx = opt_err_ctx || ctx;
+        init(ctx);
+        opt_onErrorFunc = opt_onErrorFunc || function(err, functionName, args) {
+            // apparently we can't do args.join(",");
+            var argStr = "";
+            var numArgs = args.length;
+            for (var ii = 0; ii < numArgs; ++ii) {
+                argStr += ((ii == 0) ? '' : ', ') +
+                    glFunctionArgToString(functionName, numArgs, ii, args[ii]);
+            }
+            error("WebGL error "+ glEnumToString(err) + " in "+ functionName +
+                "(" + argStr + ")");
+        };
+
+        // Holds booleans for each GL error so after we get the error ourselves
+        // we can still return it to the client app.
+        var glErrorShadow = { };
+
+        // Makes a function that calls a WebGL function and then calls getError.
+        function makeErrorWrapper(ctx, functionName) {
+            return function() {
+                if (opt_onFunc) {
+                    opt_onFunc(functionName, arguments);
+                }
+                var result = ctx[functionName].apply(ctx, arguments);
+                var err = opt_err_ctx.getError();
+                if (err != 0) {
+                    glErrorShadow[err] = true;
+                    opt_onErrorFunc(err, functionName, arguments);
+                }
+                return result;
+            };
+        }
+
+        // Make a an object that has a copy of every property of the WebGL context
+        // but wraps all functions.
+        var wrapper = {};
+        for (var propertyName in ctx) {
+            if (typeof ctx[propertyName] == 'function') {
+                if (propertyName != 'getExtension') {
+                    wrapper[propertyName] = makeErrorWrapper(ctx, propertyName);
+                } else {
+                    var wrapped = makeErrorWrapper(ctx, propertyName);
+                    wrapper[propertyName] = function () {
+                        var result = wrapped.apply(ctx, arguments);
+                        if (!result) {
+                            return null;
+                        }
+                        return makeDebugContext(result, opt_onErrorFunc, opt_onFunc, opt_err_ctx);
+                    };
+                }
+            } else {
+                makePropertyWrapper(wrapper, ctx, propertyName);
+            }
+        }
+
+        // Override the getError function with one that returns our saved results.
+        wrapper.getError = function() {
+            for (var err in glErrorShadow) {
+                if (glErrorShadow.hasOwnProperty(err)) {
+                    if (glErrorShadow[err]) {
+                        glErrorShadow[err] = false;
+                        return err;
+                    }
+                }
+            }
+            return ctx.NO_ERROR;
+        };
+
+        return wrapper;
+    }
+
+    function resetToInitialState(ctx) {
+        var isWebGL2RenderingContext = !!ctx.createTransformFeedback;
+
+        if (isWebGL2RenderingContext) {
+            ctx.bindVertexArray(null);
+        }
+
+        var numAttribs = ctx.getParameter(ctx.MAX_VERTEX_ATTRIBS);
+        var tmp = ctx.createBuffer();
+        ctx.bindBuffer(ctx.ARRAY_BUFFER, tmp);
+        for (var ii = 0; ii < numAttribs; ++ii) {
+            ctx.disableVertexAttribArray(ii);
+            ctx.vertexAttribPointer(ii, 4, ctx.FLOAT, false, 0, 0);
+            ctx.vertexAttrib1f(ii, 0);
+            if (isWebGL2RenderingContext) {
+                ctx.vertexAttribDivisor(ii, 0);
+            }
+        }
+        ctx.deleteBuffer(tmp);
+
+        var numTextureUnits = ctx.getParameter(ctx.MAX_TEXTURE_IMAGE_UNITS);
+        for (var ii = 0; ii < numTextureUnits; ++ii) {
+            ctx.activeTexture(ctx.TEXTURE0 + ii);
+            ctx.bindTexture(ctx.TEXTURE_CUBE_MAP, null);
+            ctx.bindTexture(ctx.TEXTURE_2D, null);
+            if (isWebGL2RenderingContext) {
+                ctx.bindTexture(ctx.TEXTURE_2D_ARRAY, null);
+                ctx.bindTexture(ctx.TEXTURE_3D, null);
+                ctx.bindSampler(ii, null);
+            }
+        }
+
+        ctx.activeTexture(ctx.TEXTURE0);
+        ctx.useProgram(null);
+        ctx.bindBuffer(ctx.ARRAY_BUFFER, null);
+        ctx.bindBuffer(ctx.ELEMENT_ARRAY_BUFFER, null);
+        ctx.bindFramebuffer(ctx.FRAMEBUFFER, null);
+        ctx.bindRenderbuffer(ctx.RENDERBUFFER, null);
+        ctx.disable(ctx.BLEND);
+        ctx.disable(ctx.CULL_FACE);
+        ctx.disable(ctx.DEPTH_TEST);
+        ctx.disable(ctx.DITHER);
+        ctx.disable(ctx.SCISSOR_TEST);
+        ctx.blendColor(0, 0, 0, 0);
+        ctx.blendEquation(ctx.FUNC_ADD);
+        ctx.blendFunc(ctx.ONE, ctx.ZERO);
+        ctx.clearColor(0, 0, 0, 0);
+        ctx.clearDepth(1);
+        ctx.clearStencil(-1);
+        ctx.colorMask(true, true, true, true);
+        ctx.cullFace(ctx.BACK);
+        ctx.depthFunc(ctx.LESS);
+        ctx.depthMask(true);
+        ctx.depthRange(0, 1);
+        ctx.frontFace(ctx.CCW);
+        ctx.hint(ctx.GENERATE_MIPMAP_HINT, ctx.DONT_CARE);
+        ctx.lineWidth(1);
+        ctx.pixelStorei(ctx.PACK_ALIGNMENT, 4);
+        ctx.pixelStorei(ctx.UNPACK_ALIGNMENT, 4);
+        ctx.pixelStorei(ctx.UNPACK_FLIP_Y_WEBGL, false);
+        ctx.pixelStorei(ctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+        // TODO: Delete this IF.
+        if (ctx.UNPACK_COLORSPACE_CONVERSION_WEBGL) {
+            ctx.pixelStorei(ctx.UNPACK_COLORSPACE_CONVERSION_WEBGL, ctx.BROWSER_DEFAULT_WEBGL);
+        }
+        ctx.polygonOffset(0, 0);
+        ctx.sampleCoverage(1, false);
+        ctx.scissor(0, 0, ctx.canvas.width, ctx.canvas.height);
+        ctx.stencilFunc(ctx.ALWAYS, 0, 0xFFFFFFFF);
+        ctx.stencilMask(0xFFFFFFFF);
+        ctx.stencilOp(ctx.KEEP, ctx.KEEP, ctx.KEEP);
+        ctx.viewport(0, 0, ctx.canvas.width, ctx.canvas.height);
+        ctx.clear(ctx.COLOR_BUFFER_BIT | ctx.DEPTH_BUFFER_BIT | ctx.STENCIL_BUFFER_BIT);
+
+        if (isWebGL2RenderingContext) {
+            ctx.drawBuffers([ctx.BACK]);
+            ctx.readBuffer(ctx.BACK);
+            ctx.bindBuffer(ctx.COPY_READ_BUFFER, null);
+            ctx.bindBuffer(ctx.COPY_WRITE_BUFFER, null);
+            ctx.bindBuffer(ctx.PIXEL_PACK_BUFFER, null);
+            ctx.bindBuffer(ctx.PIXEL_UNPACK_BUFFER, null);
+            var numTransformFeedbacks = ctx.getParameter(ctx.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
+            for (var ii = 0; ii < numTransformFeedbacks; ++ii) {
+                ctx.bindBufferBase(ctx.TRANSFORM_FEEDBACK_BUFFER, ii, null);
+            }
+            var numUBOs = ctx.getParameter(ctx.MAX_UNIFORM_BUFFER_BINDINGS);
+            for (var ii = 0; ii < numUBOs; ++ii) {
+                ctx.bindBufferBase(ctx.UNIFORM_BUFFER, ii, null);
+            }
+            ctx.disable(ctx.RASTERIZER_DISCARD);
+            ctx.pixelStorei(ctx.UNPACK_IMAGE_HEIGHT, 0);
+            ctx.pixelStorei(ctx.UNPACK_SKIP_IMAGES, 0);
+            ctx.pixelStorei(ctx.UNPACK_ROW_LENGTH, 0);
+            ctx.pixelStorei(ctx.UNPACK_SKIP_ROWS, 0);
+            ctx.pixelStorei(ctx.UNPACK_SKIP_PIXELS, 0);
+            ctx.pixelStorei(ctx.PACK_ROW_LENGTH, 0);
+            ctx.pixelStorei(ctx.PACK_SKIP_ROWS, 0);
+            ctx.pixelStorei(ctx.PACK_SKIP_PIXELS, 0);
+            ctx.hint(ctx.FRAGMENT_SHADER_DERIVATIVE_HINT, ctx.DONT_CARE);
+        }
+
+        // TODO: This should NOT be needed but Firefox fails with 'hint'
+        while(ctx.getError());
+    }
+
+    function makeLostContextSimulatingCanvas(canvas) {
+        var unwrappedContext_;
+        var wrappedContext_;
+        var onLost_ = [];
+        var onRestored_ = [];
+        var wrappedContext_ = {};
+        var contextId_ = 1;
+        var contextLost_ = false;
+        var resourceDb_ = [];
+        var numCallsToLoseContext_ = 0;
+        var numCalls_ = 0;
+        var canRestore_ = false;
+        var restoreTimeout_ = 0;
+        var isWebGL2RenderingContext;
+
+        // Holds booleans for each GL error so can simulate errors.
+        var glErrorShadow_ = { };
+
+        canvas.getContext = function(f) {
+            return function() {
+                var ctx = f.apply(canvas, arguments);
+                // Did we get a context and is it a WebGL context?
+                if ((ctx instanceof WebGLRenderingContext) || (window.WebGL2RenderingContext && (ctx instanceof WebGL2RenderingContext))) {
+                    if (ctx != unwrappedContext_) {
+                        if (unwrappedContext_) {
+                            throw "got different context"
+                        }
+                        isWebGL2RenderingContext = window.WebGL2RenderingContext && (ctx instanceof WebGL2RenderingContext);
+                        unwrappedContext_ = ctx;
+                        wrappedContext_ = makeLostContextSimulatingContext(unwrappedContext_);
+                    }
+                    return wrappedContext_;
+                }
+                return ctx;
+            }
+        }(canvas.getContext);
+
+        function wrapEvent(listener) {
+            if (typeof(listener) == "function") {
+                return listener;
+            } else {
+                return function(info) {
+                    listener.handleEvent(info);
+                }
+            }
+        }
+
+        var addOnContextLostListener = function(listener) {
+            onLost_.push(wrapEvent(listener));
+        };
+
+        var addOnContextRestoredListener = function(listener) {
+            onRestored_.push(wrapEvent(listener));
+        };
+
+
+        function wrapAddEventListener(canvas) {
+            var f = canvas.addEventListener;
+            canvas.addEventListener = function(type, listener, bubble) {
+                switch (type) {
+                    case 'webglcontextlost':
+                        addOnContextLostListener(listener);
+                        break;
+                    case 'webglcontextrestored':
+                        addOnContextRestoredListener(listener);
+                        break;
+                    default:
+                        f.apply(canvas, arguments);
+                }
+            };
+        }
+
+        wrapAddEventListener(canvas);
+
+        canvas.loseContext = function() {
+            if (!contextLost_) {
+                contextLost_ = true;
+                numCallsToLoseContext_ = 0;
+                ++contextId_;
+                while (unwrappedContext_.getError());
+                clearErrors();
+                glErrorShadow_[unwrappedContext_.CONTEXT_LOST_WEBGL] = true;
+                var event = makeWebGLContextEvent("context lost");
+                var callbacks = onLost_.slice();
+                setTimeout(function() {
+                    //log("numCallbacks:" + callbacks.length);
+                    for (var ii = 0; ii < callbacks.length; ++ii) {
+                        //log("calling callback:" + ii);
+                        callbacks[ii](event);
+                    }
+                    if (restoreTimeout_ >= 0) {
+                        setTimeout(function() {
+                            canvas.restoreContext();
+                        }, restoreTimeout_);
+                    }
+                }, 0);
+            }
+        };
+
+        canvas.restoreContext = function() {
+            if (contextLost_) {
+                if (onRestored_.length) {
+                    setTimeout(function() {
+                        if (!canRestore_) {
+                            throw "can not restore. webglcontestlost listener did not call event.preventDefault";
+                        }
+                        freeResources();
+                        resetToInitialState(unwrappedContext_);
+                        contextLost_ = false;
+                        numCalls_ = 0;
+                        canRestore_ = false;
+                        var callbacks = onRestored_.slice();
+                        var event = makeWebGLContextEvent("context restored");
+                        for (var ii = 0; ii < callbacks.length; ++ii) {
+                            callbacks[ii](event);
+                        }
+                    }, 0);
+                }
+            }
+        };
+
+        canvas.loseContextInNCalls = function(numCalls) {
+            if (contextLost_) {
+                throw "You can not ask a lost contet to be lost";
+            }
+            numCallsToLoseContext_ = numCalls_ + numCalls;
+        };
+
+        canvas.getNumCalls = function() {
+            return numCalls_;
+        };
+
+        canvas.setRestoreTimeout = function(timeout) {
+            restoreTimeout_ = timeout;
+        };
+
+        function clearErrors() {
+            var k = Object.keys(glErrorShadow_);
+            for (var ii = 0; ii < k.length; ++ii) {
+                delete glErrorShadow_[k[ii]];
+            }
+        }
+
+        function loseContextIfTime() {
+            ++numCalls_;
+            if (!contextLost_) {
+                if (numCallsToLoseContext_ == numCalls_) {
+                    canvas.loseContext();
+                }
+            }
+        }
+
+        // Makes a function that simulates WebGL when out of context.
+        function makeLostContextFunctionWrapper(ctx, functionName) {
+            var f = ctx[functionName];
+            return function() {
+                // log("calling:" + functionName);
+                // Only call the functions if the context is not lost.
+                loseContextIfTime();
+                if (!contextLost_) {
+                    //if (!checkResources(arguments)) {
+                    //  glErrorShadow_[wrappedContext_.INVALID_OPERATION] = true;
+                    //  return;
+                    //}
+                    var result = f.apply(ctx, arguments);
+                    return result;
+                }
+            };
+        }
+
+        function freeResources() {
+            for (var ii = 0; ii < resourceDb_.length; ++ii) {
+                var resource = resourceDb_[ii];
+                if (resource instanceof WebGLBuffer) {
+                    unwrappedContext_.deleteBuffer(resource);
+                } else if (resource instanceof WebGLFramebuffer) {
+                    unwrappedContext_.deleteFramebuffer(resource);
+                } else if (resource instanceof WebGLProgram) {
+                    unwrappedContext_.deleteProgram(resource);
+                } else if (resource instanceof WebGLRenderbuffer) {
+                    unwrappedContext_.deleteRenderbuffer(resource);
+                } else if (resource instanceof WebGLShader) {
+                    unwrappedContext_.deleteShader(resource);
+                } else if (resource instanceof WebGLTexture) {
+                    unwrappedContext_.deleteTexture(resource);
+                }
+                else if (isWebGL2RenderingContext) {
+                    if (resource instanceof WebGLQuery) {
+                        unwrappedContext_.deleteQuery(resource);
+                    } else if (resource instanceof WebGLSampler) {
+                        unwrappedContext_.deleteSampler(resource);
+                    } else if (resource instanceof WebGLSync) {
+                        unwrappedContext_.deleteSync(resource);
+                    } else if (resource instanceof WebGLTransformFeedback) {
+                        unwrappedContext_.deleteTransformFeedback(resource);
+                    } else if (resource instanceof WebGLVertexArrayObject) {
+                        unwrappedContext_.deleteVertexArray(resource);
+                    }
+                }
+            }
+        }
+
+        function makeWebGLContextEvent(statusMessage) {
+            return {
+                statusMessage: statusMessage,
+                preventDefault: function() {
+                    canRestore_ = true;
+                }
+            };
+        }
+
+        return canvas;
+
+        function makeLostContextSimulatingContext(ctx) {
+            // copy all functions and properties to wrapper
+            for (var propertyName in ctx) {
+                if (typeof ctx[propertyName] == 'function') {
+                    wrappedContext_[propertyName] = makeLostContextFunctionWrapper(
+                        ctx, propertyName);
+                } else {
+                    makePropertyWrapper(wrappedContext_, ctx, propertyName);
+                }
+            }
+
+            // Wrap a few functions specially.
+            wrappedContext_.getError = function() {
+                loseContextIfTime();
+                if (!contextLost_) {
+                    var err;
+                    while (err = unwrappedContext_.getError()) {
+                        glErrorShadow_[err] = true;
+                    }
+                }
+                for (var err in glErrorShadow_) {
+                    if (glErrorShadow_[err]) {
+                        delete glErrorShadow_[err];
+                        return err;
+                    }
+                }
+                return wrappedContext_.NO_ERROR;
+            };
+
+            var creationFunctions = [
+                "createBuffer",
+                "createFramebuffer",
+                "createProgram",
+                "createRenderbuffer",
+                "createShader",
+                "createTexture"
+            ];
+            if (isWebGL2RenderingContext) {
+                creationFunctions.push(
+                    "createQuery",
+                    "createSampler",
+                    "fenceSync",
+                    "createTransformFeedback",
+                    "createVertexArray"
+                );
+            }
+            for (var ii = 0; ii < creationFunctions.length; ++ii) {
+                var functionName = creationFunctions[ii];
+                wrappedContext_[functionName] = function(f) {
+                    return function() {
+                        loseContextIfTime();
+                        if (contextLost_) {
+                            return null;
+                        }
+                        var obj = f.apply(ctx, arguments);
+                        obj.__webglDebugContextLostId__ = contextId_;
+                        resourceDb_.push(obj);
+                        return obj;
+                    };
+                }(ctx[functionName]);
+            }
+
+            var functionsThatShouldReturnNull = [
+                "getActiveAttrib",
+                "getActiveUniform",
+                "getBufferParameter",
+                "getContextAttributes",
+                "getAttachedShaders",
+                "getFramebufferAttachmentParameter",
+                "getParameter",
+                "getProgramParameter",
+                "getProgramInfoLog",
+                "getRenderbufferParameter",
+                "getShaderParameter",
+                "getShaderInfoLog",
+                "getShaderSource",
+                "getTexParameter",
+                "getUniform",
+                "getUniformLocation",
+                "getVertexAttrib"
+            ];
+            if (isWebGL2RenderingContext) {
+                functionsThatShouldReturnNull.push(
+                    "getInternalformatParameter",
+                    "getQuery",
+                    "getQueryParameter",
+                    "getSamplerParameter",
+                    "getSyncParameter",
+                    "getTransformFeedbackVarying",
+                    "getIndexedParameter",
+                    "getUniformIndices",
+                    "getActiveUniforms",
+                    "getActiveUniformBlockParameter",
+                    "getActiveUniformBlockName"
+                );
+            }
+            for (var ii = 0; ii < functionsThatShouldReturnNull.length; ++ii) {
+                var functionName = functionsThatShouldReturnNull[ii];
+                wrappedContext_[functionName] = function(f) {
+                    return function() {
+                        loseContextIfTime();
+                        if (contextLost_) {
+                            return null;
+                        }
+                        return f.apply(ctx, arguments);
+                    }
+                }(wrappedContext_[functionName]);
+            }
+
+            var isFunctions = [
+                "isBuffer",
+                "isEnabled",
+                "isFramebuffer",
+                "isProgram",
+                "isRenderbuffer",
+                "isShader",
+                "isTexture"
+            ];
+            if (isWebGL2RenderingContext) {
+                isFunctions.push(
+                    "isQuery",
+                    "isSampler",
+                    "isSync",
+                    "isTransformFeedback",
+                    "isVertexArray"
+                );
+            }
+            for (var ii = 0; ii < isFunctions.length; ++ii) {
+                var functionName = isFunctions[ii];
+                wrappedContext_[functionName] = function(f) {
+                    return function() {
+                        loseContextIfTime();
+                        if (contextLost_) {
+                            return false;
+                        }
+                        return f.apply(ctx, arguments);
+                    }
+                }(wrappedContext_[functionName]);
+            }
+
+            wrappedContext_.checkFramebufferStatus = function(f) {
+                return function() {
+                    loseContextIfTime();
+                    if (contextLost_) {
+                        return wrappedContext_.FRAMEBUFFER_UNSUPPORTED;
+                    }
+                    return f.apply(ctx, arguments);
+                };
+            }(wrappedContext_.checkFramebufferStatus);
+
+            wrappedContext_.getAttribLocation = function(f) {
+                return function() {
+                    loseContextIfTime();
+                    if (contextLost_) {
+                        return -1;
+                    }
+                    return f.apply(ctx, arguments);
+                };
+            }(wrappedContext_.getAttribLocation);
+
+            wrappedContext_.getVertexAttribOffset = function(f) {
+                return function() {
+                    loseContextIfTime();
+                    if (contextLost_) {
+                        return 0;
+                    }
+                    return f.apply(ctx, arguments);
+                };
+            }(wrappedContext_.getVertexAttribOffset);
+
+            wrappedContext_.isContextLost = function() {
+                return contextLost_;
+            };
+
+            if (isWebGL2RenderingContext) {
+                wrappedContext_.getFragDataLocation = function(f) {
+                    return function() {
+                        loseContextIfTime();
+                        if (contextLost_) {
+                            return -1;
+                        }
+                        return f.apply(ctx, arguments);
+                    };
+                }(wrappedContext_.getFragDataLocation);
+
+                wrappedContext_.clientWaitSync = function(f) {
+                    return function() {
+                        loseContextIfTime();
+                        if (contextLost_) {
+                            return wrappedContext_.WAIT_FAILED;
+                        }
+                        return f.apply(ctx, arguments);
+                    };
+                }(wrappedContext_.clientWaitSync);
+
+                wrappedContext_.getUniformBlockIndex = function(f) {
+                    return function() {
+                        loseContextIfTime();
+                        if (contextLost_) {
+                            return wrappedContext_.INVALID_INDEX;
+                        }
+                        return f.apply(ctx, arguments);
+                    };
+                }(wrappedContext_.getUniformBlockIndex);
+            }
+
+            return wrappedContext_;
+        }
+    }
+
+    return {
+        /**
+         * Initializes this module. Safe to call more than once.
+         * @param {!WebGLRenderingContext} ctx A WebGL context. If
+         *    you have more than one context it doesn't matter which one
+         *    you pass in, it is only used to pull out constants.
+         */
+        'init': init,
+
+        /**
+         * Returns true or false if value matches any WebGL enum
+         * @param {*} value Value to check if it might be an enum.
+         * @return {boolean} True if value matches one of the WebGL defined enums
+         */
+        'mightBeEnum': mightBeEnum,
+
+        /**
+         * Gets an string version of an WebGL enum.
+         *
+         * Example:
+         *   WebGLDebugUtil.init(ctx);
+         *   var str = WebGLDebugUtil.glEnumToString(ctx.getError());
+         *
+         * @param {number} value Value to return an enum for
+         * @return {string} The string version of the enum.
+         */
+        'glEnumToString': glEnumToString,
+
+        /**
+         * Converts the argument of a WebGL function to a string.
+         * Attempts to convert enum arguments to strings.
+         *
+         * Example:
+         *   WebGLDebugUtil.init(ctx);
+         *   var str = WebGLDebugUtil.glFunctionArgToString('bindTexture', 2, 0, gl.TEXTURE_2D);
+         *
+         * would return 'TEXTURE_2D'
+         *
+         * @param {string} functionName the name of the WebGL function.
+         * @param {number} numArgs The number of arguments
+         * @param {number} argumentIndx the index of the argument.
+         * @param {*} value The value of the argument.
+         * @return {string} The value as a string.
+         */
+        'glFunctionArgToString': glFunctionArgToString,
+
+        /**
+         * Converts the arguments of a WebGL function to a string.
+         * Attempts to convert enum arguments to strings.
+         *
+         * @param {string} functionName the name of the WebGL function.
+         * @param {number} args The arguments.
+         * @return {string} The arguments as a string.
+         */
+        'glFunctionArgsToString': glFunctionArgsToString,
+
+        /**
+         * Given a WebGL context returns a wrapped context that calls
+         * gl.getError after every command and calls a function if the
+         * result is not NO_ERROR.
+         *
+         * You can supply your own function if you want. For example, if you'd like
+         * an exception thrown on any GL error you could do this
+         *
+         *    function throwOnGLError(err, funcName, args) {
+         *      throw WebGLDebugUtils.glEnumToString(err) +
+         *            " was caused by call to " + funcName;
+         *    };
+         *
+         *    ctx = WebGLDebugUtils.makeDebugContext(
+         *        canvas.getContext("webgl"), throwOnGLError);
+         *
+         * @param {!WebGLRenderingContext} ctx The webgl context to wrap.
+         * @param {!function(err, funcName, args): void} opt_onErrorFunc The function
+         *     to call when gl.getError returns an error. If not specified the default
+         *     function calls console.log with a message.
+         * @param {!function(funcName, args): void} opt_onFunc The
+         *     function to call when each webgl function is called. You
+         *     can use this to log all calls for example.
+         */
+        'makeDebugContext': makeDebugContext,
+
+        /**
+         * Given a canvas element returns a wrapped canvas element that will
+         * simulate lost context. The canvas returned adds the following functions.
+         *
+         * loseContext:
+         *   simulates a lost context event.
+         *
+         * restoreContext:
+         *   simulates the context being restored.
+         *
+         * lostContextInNCalls:
+         *   loses the context after N gl calls.
+         *
+         * getNumCalls:
+         *   tells you how many gl calls there have been so far.
+         *
+         * setRestoreTimeout:
+         *   sets the number of milliseconds until the context is restored
+         *   after it has been lost. Defaults to 0. Pass -1 to prevent
+         *   automatic restoring.
+         *
+         * @param {!Canvas} canvas The canvas element to wrap.
+         */
+        'makeLostContextSimulatingCanvas': makeLostContextSimulatingCanvas,
+
+        /**
+         * Resets a context to the initial state.
+         * @param {!WebGLRenderingContext} ctx The webgl context to
+         *     reset.
+         */
+        'resetToInitialState': resetToInitialState
+    };
+
+}();
+
+export { WebGLDebugUtils as default };
+//# sourceMappingURL=webgl-debug.js.map