[HOpenGL] GL utilities, toolkits, and questions..

[C.Reinke]

Hi again,

given GL's separation of low-level features and other useful stuff,
there are a lot of GL utilities around that make GL life less
painful. I've been wondering whether anyone is working on making
some of those available or willing to share their own hacks in 
those areas.  Typical examples:

1. fonts.. there are n+1 ways to make fonts with GL, so of course
           none of them are part of the standard

  fortunately, GLUT has some minimal support, but there must be
  GL bindings to/converters from free fonts (or at least system 
  fonts:-( around. 

* aside: there's something odd with GLUT's stroke font width.
* HOpenGL returns that as an Int, which seems to match the spec,
* but doesn't make sense to me.. "width in pixels" of a stroke
* font??? is that a copy and paste error from the preceding
* section on bitmap fonts?

* oh, and why is the default stroke font size so huge? I have
* to scale it down by a factor of 100, it seems, to get into
* natural proportions..

2. snapshots/printing.. again, GL provides only the foundations

  we all want to show what we do to people who don't have GHC,
  GLUT, ..  of course, you can snapshot static scenes using system
  tools, but it would be nicer to produce snapshots, preferredly
  animated (what format, though?), from within HOpenGL. using
  feedback from the framebuffer, that seems possible. The GL pages
  also talk about printer-resolution printing by rendering the scene
  in tiles. could one export 2d-vector graphics (postscript/SVG)
  from HOpenGL, or always just pixmaps?

3. scene graph libraries.. who wants to play with all the low-level
                           details all the time?

  as it happens, I'm working on this part;-) work in progress, but 
  see http://www.cs.ukc.ac.uk/people/staff/cr3/FunWorlds/ for 
  outlines of where I'm headed with this. no screen shots yet
  (see 2 for why), so here's a brief summary of the state of 
  things
    - static scene graphs and translation to HOpenGL: are 
      relatively straightforward, and I had some experience with
      VRML-style scene graphs, so that part only grows on demand
    - dynamic scene graphs: if you've seen my earlier experiments
      with FunWorlds/VRML, you know that I'm playing with Fran
      concepts here, but I've now made some modifications to 
      Fran basic, with which I'm quite happy so far (that's the 
      research aspect and hence the current focus)

4. shadows?  

  there seem to be several techniques - is any of them generally
  applicable (not just shadows on static planes) and portable?

5. GUIs? 

  Sven mentioned several a while ago, one of which looked quite
  reasonable.

6. others?-)

And while we're at it (some have started already): what are you
doing/hoping to do with HOpenGL (not just dozens of private 
versions of Haskell DOOM, I hope?-)?

Claus