[Greenengine-developer] stuff's getting done, really!

[Jeremy B. <bel...@gm...>]

Just a head's up, I'm working on getting the grun makefile target up, 
and I'm also taking a bit of a sidetrack from the /engine directory and 
implementing the /backend directory a bit, so that the /engine can have 
some context and I can test it out on a working system (with actual 
graphics). Here's what I'm getting setup so far:

    * RenderSystem: This is the abstract base class of all the rendering
      system, which handles all of the drawing and such.
    * GLRenderSystem: The implementation of RenderSystem for custom
      OpenGL rendering (non-Ogre).
    * Application: Basically the abstract event loop responder. The
      windowing system backend (in this case, glutApp) forwards system
      events to the Application, which sends commands to the
      RenderSystem. This has the potential to be the base class of the
      Engine class, or possibly the base class of a class that contains
      the Engine class. I haven't decided yet.
    * glutApp: the Windowing system backend for Application, which uses
      GLUT for events and window management, and OpenGL for rendering.
    * GRunApplication: This will be the Application subclass to run our
      game. It's basically the Engine class or possibly it contains the
      Engine class as a member. I haven't decided yet.
    * System: System is the abstraction layer between the Engine and
      EntityInstance/BehaviorInstance classes. IE, queue'd entity spawns
      and message passing interface.

In other words, RenderSystem is an abstraction layer between the backend 
(glutApp) and Application, which is backend-independent (doesn't need to 
know anything about glutApp). In the case of GLUT, glutApp doesn't even 
need to know about GLRenderSystem really, but ogreApp might need to, and 
Application doesn't care whether glutApp or ogreApp knows about the 
RenderSystem being used, or even of the existence of glutApp or ogreApp.

So yeah, beautiful.
Regards,
Jeremy