Descent supports the notion of the top texture being able to specify points
you can see through not only itself, but also the texture below it.

Both methods require GL_NV_register_combiners.
Both methods can probably be implemented with fragment programs, but I
haven't looked into those much at all. (Considering I don't have a card
supporting them..)

method 1: For super-transparent textures, the alpha channel works as normal,
and the inverse of the blue channel controls the alpha of the lower texture.
(Thus if the alpha is 255, then the lower texture is not visible so using blue
cause any bad effects, and at alpha 0, then the blue used to modify the lower
textures alpha won't be visible.)
 * pro?: can also be implemented with GL_NV_texture_env_combine4, though it
   breaks the spec it works anyway, at least on my gf2.  (OTOH, any card that
   supports GL_NV_texture_env_combine4 probably supports
   GL_NV_register_combiners as well, so this is a pretty useless point.)
 * If alpha is 0, you can fully control the alpha of the lower texture.
 * If alpha is >0, and blue=0, you can draw partially transparent stuff on top,
   but only using red and green. (or get weird effects where the lower texture
   becomes transparent when the upper one uses blue ;)
 * If alpha is 255, everything is normal.(Since only the top texture is visible)

method 2: The alpha byte is mapped in a range of:
 0:loweralpha=255,upper=0  ->  127.5:lower=0,upper=0  ->  255:lower=0,upper=255 
 * pro: cleaner usage of partially transparent textures. (But not both upper
   and lower at once...)
 * con: there is no 127.5, so the best you can do is 127:lower=1,upper=0 or
   128:lower=0,upper=1. (Though it doesn't seem to be visually possible to tell
   at that low of an alpha)
 * note: the originally considered mapping was:
   0:lower=0,upper=0  ->  127.5:lower=255,upper=0  ->  255:lower=255,upper=255 
   But this causes problems with paletted textures.  (The value for transparency
   suddenly becomes super-transparent.  Hm, this could be worked around by
   modifying all super-transparent paletted textures as they were loaded to
   switch their trans/super-trans indices around.)


method 3?: Put off doing anything on this in the hope that some better solution 
might be possible with fragment programs?
 * pro: it might be better
 * con: would require newer hardware
 * possible methods:
   * implement method 2, but special case 127 and/or 128 to have lower=upper=0
   * Treat 8 bit alpha as two seperate 4 bit alpha values. (not sure this would
     be possible, even with fragment programs)