* Object Hierarchy:
-- Vertex
----- Mesh
------- Circle
------- Parallelogram
------- Square
------- Triangle

Mesh has multiple Face objects
Face has multiple Edge objects
Edge has multiple Vertex objects
Vertex has multiple vector3f objects

The reasons Mesh derives from Vertex is so we can animate the object as a whole - Vertex
is really a physical object that can be rigidly transformed in a physically correct way. 
Each vertex of the objects can also be animated in this way to allow deformations of the
basic shape.

* Important method additions in the class hierarchy:
Vertex adds the Update(float timedelta) method, to be called once per game loop.
Mesh adds the Draw() method, to be called once per render loop. It also overrides Update().
Circle(), Square(), etc, override Update() and Draw() to do their own thing.

* Example of Factory pattern:
UIMap::CreateShape(int type, int x, int y);

* Comments
vector3f should probably be templatized, but it's all I needed for this project. The
benefits of operator overloading are immensely apparent in this class.

I think the object class hierarchy could have been a little stronger, with an abstract base
class representing a Shape.  I guess the Mesh does this, but it's not abstract, despite the
fact it should never be instantiated.

In the greater application, the interaction behavior between the various shapes should have
been implemented in their respective objects, thus bringing in some OO benefits. Instead,
I implemented in as a huge switch statement in the manager UIMap. Maybe at the time I had a
good reason...

For outputting text to the screen or to a file, I'm not a big fan of C++ iostreams. I much
prefer the printf() family of functions.

