Platform-specific guides » JavaScript, HTML5 and WebGL

Building, testing and deploying HTML5 and WebGL projects.

The following guide explains basic workflow of using Emscripten for deploying HTML5 apps using WebGL.

At the very least you need to have Emscripten installed. Running console applications requires Node.js, running browser apps require a webserver that's able to serve static content (for example Apache, if you have Python installed, it has a builtin webserver too).

Cross-compilation to Emscripten is done using a CMake toolchain that's part of the toolchains repository at https://github.com/mosra/toolchains. Add it as a submodule to your project or fetch the contents any other way that suits your project. The following guide will assume the contents of the repository are placed in a toolchains/ subdirectory.

git submodule add git://github.com/mosra/toolchains

There are two toolchain files. The generic/Emscripten.cmake is for the classical (asm.js) build, the generic/Emscripten-wasm.cmake is for WebAssembly build. The following guide will work with the WASM toolchain. Don't forget to adapt EMSCRIPTEN_PREFIX variable in toolchains/generic/Emscripten*.cmake to path where Emscripten is installed; you can also pass it explicitly on command-line using -DEMSCRIPTEN_PREFIX. Default is /usr/emscripten.

Building and running console applications

Emscripten allows you to run arbitrary console utilities and tests via Node.js, except for all code that accesses browsers APIs such as WebGL or audio. Assuming you have Magnum installed in the Emscripten path as described in Cross-compiling for Emscripten, build your project simply as this, using one of the toolchain files from above:

mkdir build-emscripten-wasm && cd build-emscripten-wasm
cmake .. \
    -DCMAKE_TOOLCHAIN_FILE="../toolchains/generic/Emscripten-wasm.cmake" \
    -DCMAKE_BUILD_TYPE=Release
cmake --build .

After that you can run the generated JavaScript file using Node.js. Note that it looks for the corresponding *.wasm file in the current directory, so you need to cd there first:

cd build-emscripten-wasm/src
node my-application.js

Building and deploying graphics apps

In case you don't have an OpenGL ES build set up yet, you need to copy FindOpenGLES2.cmake (or FindOpenGLES3.cmake) from the modules/ directory in Magnum source to the modules/ dir in your project so it is able to find the WebGL libraries.

Magnum provides an Emscripten application wrapper in Platform::Sdl2Application. See its documentation for more information about general usage. You can also use the Emscripten APIs directly or any other way.

To target the web browser, you need to provide a HTML markup for your application. Template one is below. The markup references two files, EmscriptenApplication.js and WebApplication.css, both are in the src/Magnum/Platform/ directory in the source tree and are also put into share/magnum/ inside your install prefix.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>Magnum Emscripten Application</title>
    <link rel="stylesheet" href="WebApplication.css" />
  </head>
  <body>
    <h1>Magnum Emscripten Application</h1>
    <div id="listener">
      <canvas id="module"></canvas>
      <div id="status">Initialization...</div>
      <div id="statusDescription"></div>
      <script src="EmscriptenApplication.js"></script>
      <script async="async" src="{{ application }}.js"></script>
    </div>
  </body>
</html>

Replace {{ application }} with the name of your application executable. You can modify all the files to your liking, but the HTML file must contain at least the <canvas> enclosed in listener <div>. The JavaScript file contains event listeners which print loading status on the page. The status displayed in the remaining two <div> s, if they are available. The CSS file contains a rudimentary style.

In order to deploy the app, you need to install the JS driver code, the WebAssembly binary (or the asm.js memory image, in case you are compiling with the classic asm.js toolchain), the HTML markup and the JS/CSS modules to a common location. The following CMake snippet handles all of that:

if(CORRADE_TARGET_EMSCRIPTEN)
    install(TARGETS my-application DESTINATION ${CMAKE_INSTALL_PREFIX})
    install(FILES
        my-application.html
        EmscriptenApplication.js
        WebApplication.css
        DESTINATION ${CMAKE_INSTALL_PREFIX})
    install(FILES
        ${CMAKE_CURRENT_BINARY_DIR}/my-application.js.mem
        ${CMAKE_CURRENT_BINARY_DIR}/my-application.wasm
        DESTINATION ${CMAKE_INSTALL_PREFIX} OPTIONAL)
endif()

To deploy, you can either point CMAKE_INSTALL_PREFIX to a location inside your system webserver or you can point it to an arbitrary directory and use Python's builtin webserver to serve its contents:

cd build-emscripten-wasm
cmake -DCMAKE_INSTALL_PREFIX=/path/to/my/emscripten/deploy ..
cmake --build . --target install

cd /path/to/my/emscripten/deploy
python -m http.server

After that, you can open http://localhost:8000 to see the files. Stop the webserver again by pressing Ctrl C.

Building and deploying windowless apps

In case you don't have an EGL + OpenGL ES build set up yet, you need to copy FindEGL.cmake and FindOpenGLES2.cmake (or FindOpenGLES3.cmake) from the modules/ directory in Magnum source to the modules/ dir in your project so it is able to find the EGL and WebGL libraries.

Windowless Magnum apps (i.e. apps that use the OpenGL context without a window) can be run in the browser as well using the Platform::WindowlessEglApplication class. See its documentation for more information about general usage. You can also use the Emscripten APIs directly or any other way.

Similarly to graphics apps, you need to provide a HTML markup for your application. Template one is below, its main difference from the one above is that it shows the console output instead of the canvas. The markup references two files, WindowlessEmscriptenApplication.js and WebApplication.css, both are in the src/Magnum/Platform/ directory in the source tree and are also put into share/magnum/ inside your install prefix.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>Magnum Windowless Emscripten Application</title>
    <link rel="stylesheet" href="WebApplication.css" />
  </head>
  <body>
    <h1>Magnum Windowless Emscripten Application</h1>
    <div id="listener">
      <canvas id="module" class="hidden"></canvas>
      <pre id="log"></pre>
      <div id="status">Initialization...</div>
      <div id="statusDescription"></div>
      <script src="WindowlessEmscriptenApplication.js"></script>
      <script async="async" src="{{ application }}.js"></script>
    </div>
  </body>
</html>

Replace {{ application }} with the name of your application executable. You can modify all the files to your liking, but the HTML file must contain at least the <canvas> enclosed in listener <div> and the <pre id="log"> for displaying the output. The JavaScript file contains event listeners which print loading status on the page. The status displayed in the remaining two <div> s, if they are available. The CSS file contains a rudimentary style.

Deployment is similar to graphics apps, only referencing a different JS file:

if(CORRADE_TARGET_EMSCRIPTEN)
    install(TARGETS my-application DESTINATION ${CMAKE_INSTALL_PREFIX})
    install(FILES
        my-application.html
        WindowlessEmscriptenApplication.js
        WebApplication.css
        DESTINATION ${CMAKE_INSTALL_PREFIX})
    install(FILES
        ${CMAKE_CURRENT_BINARY_DIR}/my-application.js.mem
        ${CMAKE_CURRENT_BINARY_DIR}/my-application.wasm
        DESTINATION ${CMAKE_INSTALL_PREFIX} OPTIONAL)
endif()

Terminal output, environment and command-line arguments

When running console apps using Node.js, command-line arguments and terminal output work like usual.

For graphics apps in the browser, EmscriptenApplication.js redirects all output (thus also Debug, Warning and Error) to JavaScript console. For windowless apps, WindowlessEmscriptenApplication.js redirects output to the <pre id="log"> element on the page.

It's possible to pass command-line arguments to main() using GET URL parameters. For example, /app/?foo=bar&fizz&buzz=3 will go to the app as ['--foo', 'bar', '--fizz', '--buzz', '3'].

Emscripten provides its own set of environment variables through std::getenv() and doesn't expose system environment when running through Node.js. In order to access system environment, you can use the Corrade::Utility::Arguments class, especially Corrade::Utility::Arguments::environment().

Differences between WebGL and OpenGL ES

WebGL is subset of OpenGL ES with some specific restrictions, namely requirement for unique buffer target binding, aligned buffer offset and stride and some other restrictions. The most prominent difference is that while the following was enough on desktop:

GL::Buffer vertices, indices;

On WebGL (even 2.0) you always have to initialize the buffers like this (and other target hints for UBOs etc.):

GL::Buffer vertices{GL::Buffer::TargetHint::Array},
    indices{GL::Buffer::TargetHint::ElementArray};

See GL::Buffer, GL::Mesh, GL::*Texture::setSubImage(), GL::Mesh::addVertexBuffer(), GL::Renderer::setStencilFunction(), GL::Renderer::setStencilMask() and GL::Renderer::setBlendFunction() documentation for more information. The corresponding sections in official WebGL specification provide even more detail:

Troubleshooting

First Emscripten run takes long or fails

Emscripten downloads and builds a lot of things on first startup or after upgrade. That's expected and might take quite some time. If you are calling Emscripten through the CMake toolchain, it might be attempting to bootstrap itself multiple times, taking extreme amounts of time, or even fail during the initial CMake compiler checks for various reasons such as

  File "/usr/lib/python2.7/subprocess.py", line 1025, in _execute_child
    raise child_exception
OSError: [Errno 13] Permission denied

The CMake toolchain might interfere with the bootstrap operation, causing it to fail. Solution is to wipe all Emscripten caches and trigger a rebuild of all needed libraries by compiling a minimal project, as shown in the shell snippet below — enter it into the console prior to building anything else. It will take a while to download and build various system libraries and random tools. The -s WASM=1 flag is needed in order to enable a rebuild of the binaryen tool as well:

cd /tmp
emcc --clear-cache
emcc --clear-ports
echo "int main() {}" > main.cpp
em++ -s WASM=1 main.cpp

CMake can't find _CORRADE_MODULE_DIR

If initial CMake configuration fails with

Could NOT find Corrade (missing: _CORRADE_MODULE_DIR)

The solution is to explicitly pass CMAKE_PREFIX_PATH pointing to directory where Corrade is installed, for example:

mkdir build-emscripten && cd build-emscripte
cmake .. \
    -DCMAKE_TOOLCHAIN_FILE=../toolchains/generic/Emscripten-wasm.cmake \
    -DCMAKE_PREFIX_PATH=/usr/lib/emscripten/system/ \
    -G Ninja

Application fails to load

Depending on what's the exact error printed in the browser console, the following scenarios are possible:

  • By default, the size of Emscripten heap is restricted to 16 MB. That might not be enough if you have large compiled-in resources or allocate large amount of memory. This can be solved either with:
    • Adding -s TOTAL_MEMORY=<bytes> to compiler/linker flags, where <bytes> is the new heap size
    • Adding -s ALLOW_MEMORY_GROWTH=1 to compiler/linker flags. This is useful in case you don't know how much memory you need in advance and might disable some optimizations.
    • Setting Module { TOTAL_MEMORY: <bytes>; } in the JavaScript driver file
  • Sometimes Chromium-based browsers refuse to create WebGL context on a particular page, while on other sites it works and the same page works in other browsers such as Firefox. This can be caused by Chromium running for too long, restart it and try again.
  • If you compile your application with a different set of compiler / linker flags or a different Emscripten version than your dependencies, it can fail to load for a variety of random reasons. Try to rebuild everything with the same set of flags.