This is not a simple Google Earth/Moon/Mars mega-texture approach where the surface is split into many tiles at many resolutions; instead we do it more like a spectral solver for PDEs on a sphere, including the time component.

The core system maps very well to a recursive functional style, and so is entirely coded in OCaml.  We then compile that to a fast native app (using labGL rendering) or to Javascript (via ocamljs and WebGL).  The latter is more interesting as every non-IE browser now supports webGL).

The big problem with webGL is that all of the engines that have so far been developed for it are based off native OpenGL engines. They try to mimic the use of 3D models, texturing and CPU side geometry used in a desktop environment; especially when porting an existing game from a mobile or native platform. Javascript has very different performance trade-offs, and not surprisingly, webGL comes into its own when used with all of the support a browser provides rather than fighting it.

For example to set up a texture from an image (ignoring preloading etc.):

function texFromElem(tex,elem) {
 gl.bindTexture(gl.TEXTURE_2D, tex);
 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, elem);
}
img = new Image();
itex = gl.createTexture();
img.onload = function() { texFromElem(itex, img); }
img.src = "some-url";

All the image loading and decoding is done for you. As an aside: really cool thing here is that texImage2D can take any HTML5 image like element. So something like this:

vid = document.createElement("video");
itex = gl.createTexture();
vid.innerHTML = "<source src='"+some_url+"'/>";
vid.autoplay = true;
setInterval(function() { texFromElem(tex, vid); }, 50) ;

…gives you a video texture ! (with some extra house keeping). Even cooler than that: the element can even be another canvas element, with either 2D or webGL inside it! (although good luck keeping the browsers stable at this point)

We’ve been developing a webGL framework that make direct use of browser-supplied parts, and we are trying to push as much of the computation as we can off into shaders. The result will be a 3D Moon interface that that has the same high-speed feel of a console game, rendering all the image data as fast as you can move around, but using real data from space and running right inside your web browser using the latest HTML5 technologies!

Although we have been developing the engine so far using ocamljs, we are also evaluating the use of js_of_ocaml. The latter works directly via bytecode compilation, which makes it easier to maintain than the patched compiler toolchain that the (otherwise excellent) ocamljs requires. Stay tuned for more news on this…

For webGL (and for a few other applications), current implementations of noise are problematic because of resource demands.  Our version of noise fixes these issues and has been gaining notice in the community.  Check out this post from WebGL.org:

“Mar 17, 2011 – Since its inception, GLSL has sadly lacked native support for noise(). A few GLSL implementations of Perlin noise have been presented over the years, but now it seems like we have a winner. Ian McEwan of Ashima Arts has come up with a very clever version of “simplex noise” that requires neither texture access nor arrays. It is compatible with WebGL, it is a set of self-contained GLSL functions with no external dependencies, and it runs fast. A demo with full source code has been posted to the GLSL developer’s forum.”

The key thing here is: this is smooth, 3D game play native in a web browser!

Ooman demonstrates our webGL Game Engine, including a scene graph system and smooth rigid-body motion interpolation. We chose an abstract but consistent artistic style to save on game art costs but provide a high-quality and high-resolution experience.

Ooman features an easy-to-use click-to-move character command system as well as the traditional WASD+QE controls. All motion and camera angles are gimbal-lock-free and can be controlled with nothing more than the left mouse button. When webGL is available for tablet computers, touch support will be trivial.

We are also releasing three small open source libraries to make WebGL development a little less oh-my-painful:

• webgl-noise is a set of 2-, 3-, and 4-D simplex noise routines which use no array or texture resources but remain fast
• webgl-diagnostic is a collection of Javascript utility functions for generating diagnostic reports about the local WebGL execution environment
• webgl-decomment is a set of GLESSL comment stripping routines in C++, Javascript, Perl, and OCaml

We’re going to use this basic engine for future projects, including our lunar explorer and 3D model display tool…

WebGL is a piece of the new HTML5 standard, and it allows direct access to the graphics card from the browser.  With WebGL, the same kinds of 3D graphical environments that can be built with OpenGL / OpenGL ES can now be built right into the browser.  In principle, a player could be in a game with a single click and from any browser on any platform (so long as the browser supports the modern HTML5 standard and has non-antiquated graphics cards / drivers).  The WebGL standard is still developing, but here’s an example of a demo game room to give some idea of the possibilities: