Webgl get error

WebGL Lint

WebGL lint wraps the WebGL API and checks for many common usage errors.
For more info see the WebGL lint website.

Spector.js

Spector.js is a system that provides a UI for inspecting your WebGL usage.
It can be used as both a devtools plugin for Chrome and Firefox or as a library. As a library it’s possible to inspect your WebGL startup code. As a devtool you can generally only inspect things once your app is running. Therefore, if you’re trying to track down an issue that happens during initialization it can be better to use Spector.js as a library so that you can programmatically enable it at your program’s initialization time.

Programmatically Debugging WebGL applications

WebGL’s error reporting mechanism involves calling getError and checking for errors. As it can be burdensome to put a getError call after every WebGL function call here is small library to help with make this easier.

https://github.com/KhronosGroup/WebGLDeveloperTools

To use the library, clone the repository, put src/debug/webgl-debug.js on your server, and include it with

<script src="webgl-debug.js"></script>

Then you can wrap your WebGLRenderingContext in an object that checks all calls like this

ctx = WebGLDebugUtils.makeDebugContext(canvas.getContext("webgl"));

This will make any GL errors show up in your browser JavaScript console.

If you want to do something else, like throw an exception you can pass in your own error handling function.

function throwOnGLError(err, funcName, args) {
  throw WebGLDebugUtils.glEnumToString(err) + " was caused by call to: " + funcName;
};

gl = canvas.getContext(...); 
gl = WebGLDebugUtils.makeDebugContext(gl, throwOnGLError);

Showing every WebGL function call

Download the webgl-debug library mentioned above. Then make a function to print the calls like this

function logGLCall(functionName, args) {   
   console.log("gl." + functionName + "(" + 
      WebGLDebugUtils.glFunctionArgsToString(functionName, args) + ")");   
} 

gl = canvas.getContext(...);
gl = WebGLDebugUtils.makeDebugContext(gl, undefined, logGLCall);

Checking that none of your arguments are undefined

One of the interesting choices of JavaScript is that it will try to coerce values of 1 type into another. This can make it hard to find bugs. For example if you do something like this

   var textureInfo = {
     tex: gl.createTexture()
   }
   gl.bindTexture(gl.TEXTURE_2D, textureInfo.tx);

Notice the typo? It’s ‘tex’ at the top but ‘tx’ at the bottom. ‘tx’ is undefined but the rules of JavaScript require that to be silently coerced into NULL which is a valid argument.

You can check for errors like this by adding a function that checks for undefined on all arguments passed to WebGL.

function validateNoneOfTheArgsAreUndefined(functionName, args) {
  for (var ii = 0; ii < args.length; ++ii) {
    if (args[ii] === undefined) {
      console.error("undefined passed to gl." + functionName + "(" +
                     WebGLDebugUtils.glFunctionArgsToString(functionName, args) + ")");
    }
  }
} 

gl = canvas.getContext(...);
gl = WebGLDebugUtils.makeDebugContext(
    gl, undefined, validateNoneOfTheArgsAreUndefined);

Combine all 3 techniques above

function logAndValidate(functionName, args) {
   logGLCall(functionName, args);
   validateNoneOfTheArgsAreUndefined (functionName, args);
}
  
gl = canvas.getContext(...);
gl = WebGLDebugUtils.makeDebugContext(gl, throwOnGLError, logAndValidate);

See a sample of the above techniques

https://github.com/KhronosGroup/WebGLDeveloperTools/blob/master/src/debug/debug-sample.html

Printing Errors and other constants

WebGL uses many constants and returns errors as numbers. It’s often easier to display those numbers as strings. With that in mind you can call WebGLDebugUtils.glEnumToString to convert a WebGL constant to a string.

Example:

WebGLDebugUtils.init(ctx);
alert(WebGLDebugUtils.glEnumToString(ctx.getError()));

Visual Studio doesn’t support debugging Unity WebGLA JavaScript API that renders 2D and 3D graphics in a web browser. The Unity WebGL build option allows Unity to publish content as JavaScript programs which use HTML5 technologies and the WebGL rendering API to run Unity content in a web browser. More info
See in Glossary content. Use the following tips to get your build information.

The browser’s JavaScript console

Unity WebGL doesn’t have access to your file system, so it doesn’t write a log file like other platforms. However, it does write all logging information such as Debug.Log, Console.WriteLine or Unity’s internal logging to the browser’s JavaScript console.

To open the JavaScript console:

• In Firefox, press Ctrl-Shift-K on Windows or Command-Option-K on a Mac.
• In Chrome, press Ctrl-Shift-J on Windows or Command-Option-J on a Mac.
• In Safari, go to Preferences > Advanced > Develop, and press Command-Option-C.
• In Microsoft Edge or Internet Explorer, press F12.

Development builds

For debugging purposes, you might want to make a development build in Unity (open the Build Settings window and enabled the Development BuildA development build includes debug symbols and enables the Profiler. More info
See in Glossary checkbox). Development builds allow you to connect the profilerA window that helps you to optimize your game. It shows how much time is spent in the various areas of your game. For example, it can report the percentage of time spent rendering, animating, or in your game logic. More info
See in Glossary, and Unity doesn’t minify them, so the emitted JavaScript code still contains human-readable (though C++-mangled) function names.
The browser uses these to display stack traces if you run into a browser error, when using Debug.LogError, or when an exception occurs and exception support is disabled. Unlike the managed stack traces that can occur when you have full exception support (see below), these stack traces have mangled names, and contain not only managed code, but also the internal UnityEngine code.

Exception support

WebGL has different levels of exception support (see documentation on Building for WebGL). By default, Unity WebGL only supports explicitly thrown exceptions. You can enable Full exception support, which emits additional checks in the IL2CPP-generated code, to catch access to null references and out-of-bounds array elements in your managed code. These additional checks significantly impact performance and increase code size and load times, so you should only use it for debugging.

Full exception support also emits function names to generate stack traces for your managed code. For this reason, stack traces appear in the console for uncaught exceptions and for Debug.Log statements. Use System.Environment.Stacktrace to get a stack trace string.

Troubleshooting

Problem: The build runs out of memory

This is a common problem, especially on 32-bit browsers. For more information on WebGL memory issues and how to fix them, see documentation on Memory in WebGL.

Problem: Files saved to Application.persistentDataPath don’t persist

Unity WebGL stores all files that must persist between sessions (such as PlayerPrefs or files saved in persistentDataPath) to the browser IndexedDB. This is an asynchronous API, so you don’t know when it’s going to complete.

Call the following code to make sure Unity flushes all pending file system write operations to the IndexedDB file system from memory:

FS.syncfs(false, function (err) {
  if (err) {
    console.log("Error: syncfs failed!"); 
  }
 });

Error message: Incorrect header check

The browser console log usually prints this error due to incorrect server configuration. For more information on how to deploy a release build, see documentation on Deploying compressed builds.

Error message: Decompressing this format (1) isn’t supported on this platform

The browser console log prints this error when the content tries to load an AssetBundle compressed using LZMA, which Unity WebGL doesn’t support. Re-compress the AssetBundle using LZ4 compressionA method of storing data that reduces the amount of storage space it requires. See Texture Compression, Animation Compression, Audio Compression, Build Compression.
See in Glossary to solve this problem. For more information on compression for WebGL, see documentation on WebGL building, particularly the AssetBundles section.

• MonoDevelop replaced with Visual Studio from 2018.1

Вернуться в Общие вопросы

Кто сейчас на конференции

Сейчас этот форум просматривают: нет зарегистрированных пользователей и гости: 11