Implement some methods, add identifying info to NYI exception on others.
Wait for our image to load so that this test works in HTML.
Additional method implementations and fixes.
Common case first.
Major overhaul of GL-based backends. (Yet another, that is.)

The motivation for this overhaul was to lay the groundwork for custom shaders,
but while I was in there revamping things, I ended up creating a 90%
implementation of GLContext (and the new shader APIs) based on GL20. This
allowed me to replace the bulk of HtmlGLContext, AndroidGLContext and
JavaGLContext with GL20Context.

Each platform still needs to handle things like uploading texture data from
platform-native image data, and Android has to handle losing/restoring
surfaces, but just about everything else is in GL20Context.

If it turns out to be feasible to write IOSGL20 (and I suspect it will), then
IOSGLContext can be slimmed down as well, and IOSGLProgram and iOSGLBuffer can
disappear. In the meanwhile though, those occupy a middle-ground abstraction
that will allow one to use custom shaders on iOS even without the "full"
implementation of IOSGL20. I put "full" in scare quotes because HtmlGL20 and
JavaGL20 are so full of holes that it's rather disingenuous to call those full
implementations themselves.

As a result of this consolidation, IndexedTrisShader is now completely platform
agnostic code and lives in core.gl. I'll port over HtmlQuadShader shortly as
well, which will make it trivially easy to use that on other platforms if
anyone ever gets around to determining that it's faster.
Nixed extra cruft.
Expose ensureTexture() via Image.

This allows GL20 using 3D games to obtain textures for images loaded via
Assets.
Added a test

g3 is a nested group layer with an animated origin.
Move the GLSL programs into IndexedTrisShader.

They are tied to its implementation and now that they're no longer shared, it
no longer makes sense for them to be in GLShader.
Custom shader support and a simple test.

I'm not 100% settled on this API, the two annoyances are:

1. You have to pass in separate texture and color shaders.
2. We have to expose GLContext via Graphics.ctx().

I'm also likely to add methods to Surface for setting the current shaders.
Right now Surface uses the shader configured for the SurfaceLayer, but that's
not really what you want. Plus you might want an ImmediateLayer wherein you
draw some images using one shader and some using another.
Further improvements to custom shaders.

We now properly inherit the shaders of our parent layer if we have no shader
configured ourselves.

It is also possible to configure the shader on a Surface, such that subsequent
drawing commands are done using that shader. ImmediateLayer pre-configures its
surface with the inherited shaders, SurfaceLayer does not. SurfaceLayer applies
the current shaders to its off-screen texture when rendering that, but when
creating the off-screen texture, there are no shaders to inherit. You can of
course configure shaders for use when rendering off-screen textures via
Surface.setShaders.
Missed some spots.
Shader overhaul to simplify custom shaders and shader customization.

The texture and color shader are now combined into a single GLShader instance,
which has to internally track whether it's being used to render textured or
colored geometry.

This simplifies custom shaders by turning setShaders(GLShader.Texture,
GLShader.Color) into setShader(GLShader) on both Layer and Surface. It also
simplifies the code that passes inherited shaders down through the paint calls.
So that's a win.

This simplifies shader customization because the previous structure required
one to create FooShader and FooShader.Texture extends FooShader and
FooShader.Color extends FooShader. That's fine for one level of customization,
but if you want to have CustomFooShader, then you can't customize both
FooShader and FooShader.Teture/Color because you can't multiply inherit in
Java. Now we have AbstractShader, which contains a Core and an Extras (which
handles the small differences between the color and texture shaders). These do
not inherit from one another, so one can extend an existing shader and
customize its core as well as its extras individually.
More missed spots! Out, damned spot!
Test the use of mouse wheel listener on a layer.

This fails to work and also crashes if the TestsGame global mouse adapter is commented out.
Fix mouse wheel on layers
Add more complex shader example with custom attributes.
Create our shader cores lazily.

This has two benefits: one, we avoid crashing if someone tries to create a
shader during Game.init, when GL is not ready to compile shaders; two, we avoid
creating a color core if a shader is only ever used to render textures.

Plus, when I get around to implementing resource management (so that custom
shaders are not giant resource leaks); we'll need to be able to destroy and
recreate the shader cores as a shader gets used and unused.
Test custom shading on an immediate layer as well.
Factor out shared bits; fix z hacking.

We need to preserve the z coordinate to get perspective correct texturing.