• The CopperLicht guys have released version 1.2.0, which has a bunch of useful changes, in particular an update to support the latest API changes.
• Another good bit of API update news: Inigo “iq” Quilez’ ShaderToy is working again!
• From Evgeny Demidov, two simple Julia set animations: number one, number two.
• Another nice demo, from Aleksandar Rodić. I like the way you can adjust everything, particularly the field of view and the near and far clipping planes.
• Also nice, if slightly nausea-inducing… a WebGL tunnel from Dennis Ippel.
• Henrik Bennetsen and Bruce Joy have proposed a WebGL-centred talk for the South by Southwest (SXSW) conference early next year; they’re crowdsourcing the talks, so if you’re going and are interested in seeing the talk, you can vote for it now.

This is a big change — I’ve fixed the tutorials on this site, and Kevin has (of course!) updated ChemDoodle, but it looks like almost every other WebGL demo out there needs updating :-( Luckily, it’s just a simple search and replace on the array types.

• Another X3DOM demo from Dennis Ippel; generating geometry from image colours.

• For those of us not able to make SIGGRAPH last week, Khronos have been good enough to post the slides for some of the WebGL presentations. They’re all worth reading through, but the big news for me was:
  • From Vladimir Vukićević’s presentation — the working group are looking to freeze the WebGL spec in September. Full production releases can’t be far behind!
  • From Ken Russell and Vangelis Kokkevis’s presentation, you can use ANGLE to run Chromium with WebGL without an OpenGL driver right now, just get a copy of ANGLE and “[d]rop libGLES2.dll and libEGL.dll in the same directory as chrome.exe” (I’ve not tried this, reports of how well it works very welcome!)
  • From Dan Lecocq’s presentation, a new WebGL library, WebGLot, for mathematical plots — looks cool! More here — thanks to Henrik Bennetsen for the direct link!
• On the subject of mathematical uses of WebGL, this looks fascinating in a brain-stretching kind of way: Voronoi Diagrams in WebGL.
• On the subject of SIGGRAPH, Dennis Ippel was there, and in a blog post he mentions that he met the X3DOM team. He gives a nice example of a demo he built using their library: a page for showing mutual Twitter friends.
• Paul Brunt ported the Flash JibLib physics library to JavaScript so that he could use it in his GLGE demos; someone else has picked up that ball and seems to be running with it. (Also via Henrik!)
• Diego Cantor, whose WebGL demos I’ve posted about before, has published a formal academic paper on using WebGL for medical imaging. This is great stuff; while most demos, frameworks and applications people are building in WebGL are based on computer games — and this is a good thing, and the right thing, as that’s where most interesting 3D applications are right now — in the long run, a lot of the most interesting stuff looks like it will come from non-gaming “real-world” applications of 3D in the browser, whether it’s medical imaging, maths (like WebGLot or the Voronoi diagrams), or chemistry, like ChemDoodle3D.
• News about Benjamin DeLillo’s WebGLU: it now supports configurable materials.
• For Polish-speaking readers, here’s what looks like another good tutorial from 3dgames.pl, this time on ambient and directional lighting.
• Evgeny Demidov has a bunch of new demos on his site, including a particularly nice furry torus. No, that’s not a euphemism :-)

If you’ve still to update your own WebGL pages to match the spec, here are the precise changes I made — they might make things easier for you.

At the start of every fragment shader, I put this:

  #ifdef GL_ES
  precision highp float;
  #endif

This is because all fragment shaders now need a qualifier to say what kind of floating-point precision they use; precision highp float gives you (as you’d expect) the highest precision. The #ifdef around it is a bit of guard code to stop this bit of code being executed in older browsers that don’t support this bit of the spec yet.

The other change I had to make was to update the way I called texImage2D. I used to do this:

    gl.texImage2D(gl.TEXTURE_2D, 0, texture.image, true);

This created a texture using the HTML image element bound to texture.image, with a mip level of 0. It also flipped the image around the X axis, which I find useful because it allows me to have texture coordinates that have Y axes that increase as you go up the screen, but to use texture images in formats like GIF, whose Y coordinates increase as you go down the image. This now requires two steps: firstly, I call gl.pixelStorei with appropriate parameters to say that all textures I use should be flipped around the X axis:

    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);

Then, when I want to create a texture, I call this:

    gl.texImage2D(
        gl.TEXTURE_2D, 0,
        gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE,
        texture.image
    );

The first two parameters are the same as before, and the last parameter is the same image as before. In the middle, we have a constant to tell WebGL that the image that we’re loading has red, green, blue and alpha components, another to say that we want to store it in the same way [UPDATE: in the comments, Benoit Jacob from the Mozilla team explains that these two must be the same value, and actually specify how the image is stored on the graphics card; so long as you're loading the image from an HTML element, WebGL knows already what format it's on], and a final one to say that each component is stored as an unsigned byte.

Those changes were all that were necessary to get everything working for me; let me know if you have any problems!

• Fragment shaders will now be validated to make sure that they are correct for WebGL / OpenGL ES; previously you could get away with using quite a lot of desktop OpenGL stuff, in particular missing out the mandatory precision specifier in fragment shaders (see the mailing list for details and a fix from Vladimir). In the short term, whether or not this validation happens will be optional, decided by the brower’s user, and off by default. However, it will become mandatory, so you should switch it on now to test your content. To switch it on:
  • In Minefield, go to about:config and change webgl.shader_validator to true.
  • In Chromium, pass --enable-glsl-translator in on the command line.
  • There are no details on how to do it in WebKit yet.
• The gl.texImage2D function has changed its signature. Brandon Jones posted about this the other week, noting that Chromium warnsyou when you use the old form; both old and new forms of the function have been supported by the browsers for a while, but the old one will soon be gone.
• As Andor Salga mentioned recently, gl.readPixels has also changed.

So, I’m going to go through all of my demos and tutorial code and change to the new APIs; if you have WebGL content live on the Web, you should too!

• On the WebGL developers’ list and on his blog, Peter Nitsch has posted about some really cool pages he’s built using Flash to access your webcam and provide textures that can be used in WebGL scenes: a cube, and adaptions of two of IQ’s demos, a kaleidoscope and a raytracer — very cool stuff! So Flash is still good for something ;-)
• An even prettier demo, also from Peter, is this Mandelbox explorer.
• I mentioned SIGGRAPH — one of the big announcements there was that AMD will be shipping EGL and OpenGL ES drivers for their graphics cards, which are better-known under their ATI brand. If you’re wondering why that’s important for WebGL, given that it works on ATI cards already, Vladimir Vukićević has an explanation.
• SceneJS V0.7.6 has been released! It’s has more new features than I can list here, so follow that link.
• Some great new demos for Paul Brunt’s GLGE: 2D filters, video textures and canvas-based textures.
• A bit of a mash-up from Dennis Ippel: visualising Last.fm data with WebGL, GLGE and jQuery.
• Here’s a formal academic paper on SpiderGL.
• Here’s a fun game from Nikolaus Gebhardt (one of the CopperLicht guys): WebGL Asteroids. The author’s written about it here, with an interesting comparison of how “ready” the different technologies he used are.
• Charles Cliffe’s CubicVR 3D engine now supports GPU fluids.
• A demo of using multiple animated lights in X3DOM.
• From Andor Salga, a useful hint about using gl.readPixels, which is currently implemented differently by different browsers.
• Andor’s XB Pointstream is going from strength to strength, and now supports streaming so that you don’t have to wait for a whole point cloud to load before you see it — useful with demos like their 22Mb model of a lion!
• Fun: some models from a computer game called “Yo Frankie!”
• From Max (aka Yi Ren) at the University of Michigan, a car modeller that he’s ported from Sketchup.
• Here’s a real-world use for WebGL: proving that the crescent moon is drawn wrongly in children’s books :-)
• If you’d like a solid introduction to WebGL, this is worth reading (via Henrik Bennetsen)