| /* |
| ** 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. |
| |
| 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': { |
| 9: { 0:true, 2:true, 6:true, 7:true }, |
| 6: { 0:true, 2:true, 3:true, 4:true }, |
| }, |
| 'texSubImage2D': { |
| 9: { 0:true, 6:true, 7:true }, |
| 7: { 0:true, 4:true, 5:true }, |
| }, |
| 'copyTexImage2D': {8: { 0:true, 2:true }}, |
| 'copyTexSubImage2D': {8: { 0:true }}, |
| 'generateMipmap': {1: { 0:true }}, |
| 'compressedTexImage2D': {7: { 0: true, 2:true }}, |
| 'compressedTexSubImage2D': {8: { 0: true, 6:true }}, |
| |
| // Buffer objects |
| |
| 'bindBuffer': {2: { 0:true }}, |
| 'bufferData': {3: { 0:true, 2:true }}, |
| 'bufferSubData': {3: { 0:true }}, |
| 'getBufferParameter': {2: { 0:true, 1:true }}, |
| |
| // Renderbuffers and framebuffers |
| |
| 'pixelStorei': {2: { 0:true, 1:true }}, |
| 'readPixels': {7: { 4:true, 5:true }}, |
| '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:true }}, |
| '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 }}, |
| }; |
| |
| /** |
| * Map of numbers to names. |
| * @type {Object} |
| */ |
| var glEnums = 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 = { }; |
| for (var propertyName in ctx) { |
| if (typeof ctx[propertyName] == 'number') { |
| glEnums[ctx[propertyName]] = 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]) { |
| 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 {number} 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; |
| }); |
| } |
| |
| // Makes a function that calls a function on another object. |
| function makeFunctionWrapper(original, functionName) { |
| //log("wrap fn: " + functionName); |
| var f = original[functionName]; |
| return function() { |
| //log("call: " + functionName); |
| var result = f.apply(original, arguments); |
| return result; |
| }; |
| } |
| |
| /** |
| * 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. |
| */ |
| function makeDebugContext(ctx, opt_onErrorFunc, opt_onFunc) { |
| 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 = 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') { |
| wrapper[propertyName] = makeErrorWrapper(ctx, propertyName); |
| } 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 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); |
| } |
| 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); |
| } |
| |
| 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); |
| |
| // 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 resourceId_ = 0; |
| var resourceDb_ = []; |
| var numCallsToLoseContext_ = 0; |
| var numCalls_ = 0; |
| var canRestore_ = false; |
| var restoreTimeout_ = 0; |
| |
| // 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) { |
| if (ctx != unwrappedContext_) { |
| if (unwrappedContext_) { |
| throw "got different context" |
| } |
| 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 isWebGLObject(obj) { |
| //return false; |
| return (obj instanceof WebGLBuffer || |
| obj instanceof WebGLFramebuffer || |
| obj instanceof WebGLProgram || |
| obj instanceof WebGLRenderbuffer || |
| obj instanceof WebGLShader || |
| obj instanceof WebGLTexture); |
| } |
| |
| function checkResources(args) { |
| for (var ii = 0; ii < args.length; ++ii) { |
| var arg = args[ii]; |
| if (isWebGLObject(arg)) { |
| return arg.__webglDebugContextLostId__ == contextId_; |
| } |
| } |
| return true; |
| } |
| |
| function clearErrors() { |
| var k = Object.keys(glErrorShadow_); |
| for (var ii = 0; ii < k.length; ++ii) { |
| delete glErrorShadow_[k]; |
| } |
| } |
| |
| 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); |
| } |
| } |
| } |
| |
| 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" |
| ]; |
| 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" |
| ]; |
| 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" |
| ]; |
| 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_; |
| }; |
| |
| 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 |
| }; |
| |
| }(); |
| |