Nuke some unnecessary semicolons
@Overrides
Speeling
Nix unused privates
Access static statically
That was renamed a while back.

Switch to the modern version, not the deprecated one.
Unused imports
Whitespace
Don't suppress that.

It isn't actually doing any sketchy-looking fallthrough that things
will warn about.
Yes, this is this.
Multitexture painting.

Instead of needing to flush every time a draw involves a new texture,
take advantage of multiple textures and allow N different at a time.
This is a particularly big win if you're repeatedly bouncing back and
forth between a few textures.

A few key points walking along the evolution of this code to help explain
some of the weirdness of its final state:

 * The nature of QuadShader really means it's easiest to add vec4s,
   not arbitrary other things, so I had to grow the size per quad more
   than I'd have liked. In an ideal world, it would've been one float
   (well, int, but there's another limitation) with the index, but I was
   immediately bumping against other issues trying to do that.
 * GLSL ES won't allow an array of textures and indexing into that, so
   now you're staring down the barrel of generated code to emulate that.
 * Oh crap. Fake indexing into an array is really a series of if/else
   statements, which is easy enough to generate, but that's branching,
   and shaders HATE branching. It works, but performance is suddenly
   WORSE than flushing between each draw.
 * If you can't do conditional code, you need to do something silly
   like get the value from every texture and multiply the ones you
   don't want by zero.
 * Oh thank god, at least the conditionals to generate ones or zeroes
   is fast, so it doesn't need to something insane like pass in actual
   ones and zeroes instead of a single index.

For QuadShader, my tests with playn-perf (which is, admittedly, pretty
contrived and lining up perfectly with what this changes) handles about
twice as many quads at the same framerate.

For IndexedTrisShader, things are a little less clear; I'm seeing virtually
identical performance before & after, but then again it keeps expanding the
vertex buffer into infinity & my machine can completely handle that. This
might play a bit differently on something less beefy.