Gleu Framework:

glcam: camera abstraction, provides free placement and movements
glhand: configurable keyboard/mouse input
gloutils: misc. functions to handle special opengl cases
glsel: facility to parse gl selection buffer
fps: fps counter
globj: opengl scene object
types: vector & matrix
vecmath: vector operations

text: globj - draw some text with attributes

sphere: globj - the wonderful planet
laminate: used by sphere

icosa: globj - the simplest globj ever

carpet: globj - an ondulating carpet
tergen: used by carpet

hex: functions to position things on the hexaboard
hexaboard: globj - draw a board
thingbot: globj

GLOBJ ABSTRACTION:

the scene viewed on screen is made from objects. we want to be able to
do the following operations on these objects :
-draw them at an arbitrary position/angle/scaling 
-perform selection, i.e. given a bounding box, the object should be
 able to tell wether it is in the bounding box or not. if the object is
 made of smaller sub-objects, or if he has distinguishable components
 (a sphere facet, for instance), the object should be able to tell which
 elements are in the bounding box.
-selection feedback. if an object and/or a sub-object is selected via
 the previously described method, there should be a way to tell the
 object to render itself in a special way, to highlight the selected
 elements.
-perform projection, i.e. given a vertex or a line, the object should be
 able to compute orthogonal projection of the vertex on the object, and
 to compute line/object intersection.

more precisely, these goals are achieved using the following interface :
-each globj provides a draw method, which uses misc. optional parameters :
    * a glcam instance, to perform rendering optimization according to
      what can or cannot be seen by the camera (avoiding drawing of hidden
      surfaces or offscreen objects). this instance can be NULL,
      thus disabling such optimizations.
    * a selection list, to allow selection feedback. each element of the
      list will include a "selector", which will be exactly what has been
      returned by the selection mechanism ; and a "highlight method", which
      will allow different highlightings. for instance, we suggest that a
      "graphic highlight" method should be always available, but additional
      highlighting methods depend on the implementation. a typical method
      could attach a floating label to the object, bearing miscellaneous 
      informations.
    * a mode, to differenciate between standard rendering and selection.
      typically, selection rendering won't apply textures and such, but it
      will setup a label stack (see openGL red book chapter about GL_SELECTION
      rendering mode).
 all parameters are optional :
    * no glcam means no optimization, without other drawback.
      on the other hand, an object may perfectly ignore the glcam parameter.
    * no selection list means no highlighting.
      on the other hand, an object which does not implement selection
      highlighting will ignore the selection list, withou other drawback.
    * an object which does not implement precise selection of subcomponents
      is free to do nothing regarding selection implementation : the object
      will still be able to be selected as a whole (the calling process will
      setup a label stack with the object ID, so it does not matter if the
      object does not add anything to the stack)
-all globj will also provide the projection method, which will take two
 vertex parameters : point, and vector. the projection method can do all
 sorts of things : <To be continued...>

from an implementation point of view, a globj is a structure holding :
    * a constructor class pointer (class-wide initialization)
    * a destructor class pointer (class-wide cleanup)
    * a draw class pointer (doing GL rendering)