Common base:
A room has a 128x128 set of tiles.
Each tile has a material type (1 byte) and 4 vertex indices (1 byte each)
An array of the 32 possible vertex positions a tile can use exists. (equally
spaced around the edge of a square) (64 floats -> 1kB)
An array for storing the color data for each material type exists.
No processing is done for tiles with the material "empty", but the frequency
of empty tiles is unknowable.


Plan A for rendering room:
Create 256kB buffer for storing vertex position data and a 192kB buffer for
vertex color data.
At room load time:
Iterate through tiles in room, transforming verts (not using OGL's matrix
library) and storing them in the buffer, and copying colors into the vertex
color buffer, tracking how many verts are actually stored.
Set the vertex position buffer to be the vertex array used by OGL, and do the
same for the vertex color buffer.
At render time:
Plow through data using glDrawArrays and the stored number of verts.
Rely on OGL to do culling.


Plan B for rendering room:
Create a 96b buffer for storing color data.  (sized to match the number of
possible verts, since the same index must be used for both)
Set the possible vertex positions buffer to be the vertex array used by OGL.
Set the color data buffer to be the color array used by OGL.
At render time:
Iterate through the part of the room that is on screen.  For each tile, copy
the colors for its material type into the color buffer at the positions
specified by its vertex indices.
Translate to the position of the tile (using OGL's matrix library) and draw
the tile with glDrawElements, passing the tiles vertex indices as the index
array.