Added is_open() so we can check if the open() succeeded.

Elimitated some const warnings from the compiler.
Minor optimization tweaks.
1999-03-27 14:04:25 +00:00 · 1999-03-27 05:34:05 +00:00 · 1999-03-25 19:02:28 +00:00 · 1999-03-25 19:01:47 +00:00 · 1999-03-15 17:58:41 +00:00 · 1999-03-13 17:34:44 +00:00
163 changed files with 27253 additions and 3000 deletions
@@ -0,0 +1,139 @@
+
+/**********************************************\
+*                                              *
+*                W A R N I N G                 *
+*                                              *
+* This file is now kept in reverse chronolog-  *
+* ical order so recent changes are now at the  *
+* top.                                         *
+*                                              *
+\**********************************************/
+
+* 28th Sept 1889 -- Fixed a bug associated with exiting the
+                      program with sounds still playing.
+                    Fixed a bug associated with using the
+                      package in the absence of a sound card.
+                    Added a new member function "working"
+                      which is the opposite of "not_working",
+                      (as demanded by a bunch of rabid optimists)!
+                    Fixed a couple of typo's in the manual.
+
+* 23rd Sept 1998 -- The Good News: Finally got around to
+                         getting the pitch envelope working. (Hooray) 
+                    The Bad News: This costs quite a bit in
+                         performance - and it was a MAJOR rewrite
+                         of significant parts of the internals,
+                         so we may need some bug fixes.
+                    This version is 0.5
+
+* 7th  July 1998 -- Fixed some error checking in slSample.cxx and
+                    a missing declaration in sl.h
+
+* 6th  July 1998 -- Fixed an initialisation problem when
+                    slScheduler was not a static/global.
+
+                    Tom Knienieder's port to SGI/IRIX is now
+                    working, documentation updated to reflect that.
+
+* 16th June 1998 -- Added some slPortability.h fixes for
+                    FreeBSD and the Cygnus WIN32 compiler.
+                    Many thanks to Curt.
+
+* 14th June 1998 -- Tom Knienieder's port to OpenBSD is now
+                    working, documentation updated to reflect that.
+                    Tom's improved Makefiles included, also some
+                    example sound samples that were accidentally
+                    left out of the release are now present.
+                    A couple of typo's in the WIN32 section
+                    have been fixed. The top level Makefile
+                    now requires you to type 'make linux',
+                    'make win' or 'make openbsd'.
+
+* 13th June 1998 -- Tom Knienieder's port to WIN32 engine is now
+                    working, documentation updated to reflect that
+                    revised status. Some default constructor parameters
+                    have changed, slDSP no longer supports setRate/setBps/setStereo.
+                    You now have to delete the slDSP and recreate it with
+                    new parameters. This makes porting a little easier.
+                    'sound_test' renamed 'example'.
+
+* 7th  June 1998 -- Volume envelopes (and inverse volume envelopes)
+                    now work correctly. Pan envelopes won't work
+                    until stereo is implemented. Pitch and filter
+                    envelopes turn out to be a major pain to implement
+                    with the present slSceduler/slSamplePlayer interface,
+                    so some significant internal changes are to be
+                    expected.
+
+                    Changed the CHANGES file to be in reverse
+                    chronological order.
+
+                    This version is officially  SL v0.3 (beta)
+ 
+*  3rd June 1998 -- Moved sample program and it's data files into
+                    'example', moved documents into 'doc' and sources
+                    into 'src'. Final library goes into 'lib'.
+
+                    The entire preempting mechanism was broken -
+                    now it's fixed.
+ 
+                    Added a callback mechanism that allows
+                    applications to know when a sound
+                    loops, finishes playing, is pre-empted, etc.
+
+                    New mechanisms added to stop/pause/resume a
+                    playing sample.
+ 
+                    All the documentation - and some of the code -
+                    for slEnvelopes has been added, they don't
+                    work yet - so don't bother with them for now.
+
+                    Made some code a little more bullet-proof.
+                    slSample's are now reference-counted so you
+                    can't accidentally delete one while it's
+                    playing without getting a FATAL error.
+
+* 2nd  June 1998 -- Fixed bug in initialisation that prevented SL
+                    from functioning correctly in the case were there
+                    is no sound card present.
+
+                    This version is officially  SL v0.2 (beta)
+
+* 1st  June 1998 -- Split library into two parts - libsm and
+                    libsl. libsm contains only the Mixer class
+                    since it is likely to be hard to port to
+                    a lot of non-OSS systems - and most programs
+                    won't need it anyway. Hence the documentation
+                    has blossomed into three files and all the
+                    'slMixer' references have turned into 'smMixer'.
+                    Also, I finally got a hold of the OSS documentation,
+                    which is a lot more complete - and straightened
+                    me out on a few points. slDSP has changed
+                    (internally) somewhat as a result and in particular,
+                    you can no longer mess with the sampling rate,
+                    stereo and bps settings after the slDSP or
+                    slScheduler has been created. This also allows the
+                    scheduler to enforce it's rule about only mono/8bps
+                    operations.
+
+                    I also added an 'autoMatch' function to the slSample
+                    class to automagically match incoming samples to the
+                    current slDSP/slScheduler. This makes using the library
+                    a lot less painful and error-prone.
+ 
+                    This version is officially  SL v0.1 (beta)
+ 
+                    We need a better name!
+
+* 30th May  1998 -- Almost total rewrite, library can now
+                    play multiple sounds without interruption,
+                    supports '.WAV' and '.AU' file formats as
+                    well as raw binary files. Able to copy with
+                    much shorter safetyMargin on sound buffers,
+                    and play without using the 'stop' call.
+                    All class and external symbols now begin
+                    with 'sl' or 'SL'. HTML documentation now
+                    available.
+
+* 27th May  1998 -- First hack
+
@@ -0,0 +1 @@
+SUBDIRS = src example
@@ -0,0 +1,9 @@
+NOTICE:  This Sound Library (SL) distribution contains source code that is
+placed into the public domain without copyright. These programs are freely
+distributable without licensing fees.  These programs are provided without
+guarantee or warrantee expressed or implied. 
+
+If you use SL in a commercial or shareware product, it would be nice if you
+gave credit where it is due.  If you make any modifications or improvements
+to SL, I would greatly appreciate a copy of the improved code.
+
@@ -0,0 +1,9 @@
+
+Hi!
+
+  This is the fifth prototype of Steve's 'SL' sound library.
+
+  Check out 'CHANGES' and the new HTML documentation.
+
+Steve
+
@@ -0,0 +1,13 @@
+
+Building SL for Linux.
+~~~~~~~~~~~~~~~~~~~~~~
+
+   % make freebsd
+   % su root
+   % make install
+
+...that's all folks.
+
+Header  files   go into /usr/include/SL (analogous to /usr/include/GL for graphics)
+Library file(s) go into /usr/lib
+
@@ -0,0 +1,13 @@
+
+Building SL for Linux.
+~~~~~~~~~~~~~~~~~~~~~~
+
+   % make linux
+   % su root
+   % make install
+
+...that's all folks.
+
+Header  files   go into /usr/include/SL (analogous to /usr/include/GL for graphics)
+Library file(s) go into /usr/lib
+
@@ -0,0 +1,13 @@
+
+Building SL for OpenBSD.
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+   % make openbsd
+   % su root
+   % make install
+
+...that's all folks.
+
+Header  files   go into /usr/include/SL (analogous to /usr/include/GL for graphics)
+Library file(s) go into /usr/lib
+
@@ -0,0 +1,27 @@
+
+Building SL for SGI.
+~~~~~~~~~~~~~~~~~~~~~~
+
+There are two options, depending on whether you want to use GCC or
+the standard SGI C++ compiler.
+
+GNU G++:
+
+   % make sgigcc
+   % su root
+   % make install
+
+SGI C++:
+
+   % make sgi
+   % su root
+   % make install
+
+...that's all folks.
+
+Header  files   go into /usr/include/SL (analogous to /usr/include/GL for graphics)
+Library file(s) go into /usr/lib
+
+When you link, be sure to include to -laudio
+
+
@@ -0,0 +1,20 @@
+Building SL for UNIX
+~~~~~~~~~~~~~~~~~~~~
+
+If your UNIX box is Linux or OpenBSD then
+check out README.linux or README.openbsd.
+
+If your UNIX box supports OSS (the Open
+Sound System) then in principal, you should
+only need to type:
+
+  % make oss
+  % su root
+  % make install
+
+...however, your milage may vary. If you succeed
+in getting a non-Linux, non-OpenBSD version to
+work, I'd like to hear about it.
+
+          Steve Baker  <sjbaker1@airmail.net>
+
@@ -0,0 +1,15 @@
+
+Building SL for win32 (msvc)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+   C:>nmake win32
+
+
+don't forget to set the environment !
+
+example:
+
+set include=c:\msdev\include;
+set lib=c:\msdev\lib
+
+path c:\msdev\bin;c:\bin;c:\winnt;......
@@ -0,0 +1,11 @@
+noinst_LIBRARIES = libBucket.a
+
+libBucket_a_SOURCES = newbucket.cxx newbucket.hxx
+
+bin_PROGRAMS = testbucket
+
+testbucket_SOURCES = testbucket.cxx
+
+testbucket_LDADD = $(top_builddir)/Lib/Bucket/libBucket.a
+
+INCLUDES += -I$(top_builddir)
@@ -0,0 +1,163 @@
+/**************************************************************************
+ * newbucket.hxx -- new bucket routines for better world modeling
+ *
+ * Written by Curtis L. Olson, started February 1999.
+ *
+ * Copyright (C) 1999  Curtis L. Olson - curt@flightgear.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ * (Log is kept at end of this file)
+ **************************************************************************/
+
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+
+#include "newbucket.hxx"
+
+
+// Build the path name for this bucket
+string FGBucket::gen_base_path() const {
+    // long int index;
+    int top_lon, top_lat, main_lon, main_lat;
+    char hem, pole;
+    char path[256];
+
+    // index = gen_index();
+
+    path[0] = '\0';
+	
+    top_lon = lon / 10;
+    main_lon = lon;
+    if ( (lon < 0) && (top_lon * 10 != lon) ) {
+	top_lon -= 1;
+    }
+    top_lon *= 10;
+    if ( top_lon >= 0 ) {
+	hem = 'e';
+    } else {
+	hem = 'w';
+	top_lon *= -1;
+    }
+    if ( main_lon < 0 ) {
+	main_lon *= -1;
+    }
+    
+    top_lat = lat / 10;
+    main_lat = lat;
+    if ( (lat < 0) && (top_lat * 10 != lat) ) {
+	top_lat -= 1;
+    }
+    top_lat *= 10;
+    if ( top_lat >= 0 ) {
+	pole = 'n';
+    } else {
+	pole = 's';
+	top_lat *= -1;
+    }
+    if ( main_lat < 0 ) {
+	main_lat *= -1;
+    }
+
+    sprintf(path, "%c%03d%c%02d/%c%03d%c%02d", 
+	    hem, top_lon, pole, top_lat,
+	    hem, main_lon, pole, main_lat);
+
+    return path;
+}
+
+
+// find the bucket which is offset by the specified tile units in the
+// X & Y direction.  We need the current lon and lat to resolve
+// ambiguities when going from a wider tile to a narrower one above or
+// below.  This assumes that we are feeding in
+FGBucket fgBucketOffset( double dlon, double dlat, int dx, int dy ) {
+    FGBucket result( dlon, dlat );
+    double clat = result.get_center_lat() + dy * FG_BUCKET_SPAN;
+
+    // walk dy units in the lat direction
+    result.set_bucket( dlon, clat );
+
+    // find the lon span for the new latitude
+    double span = bucket_span( clat );
+
+    // walk dx units in the lon direction
+    result.set_bucket( dlon + dx * span, clat );
+
+    return result;
+}
+
+
+// calculate the offset between two buckets
+void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
+
+    // Latitude difference
+    double c1_lat = b1.get_center_lat();
+    double c2_lat = b2.get_center_lat();
+    double diff_lat = c2_lat - c1_lat;
+
+#ifdef HAVE_RINT
+    *dy = (int)rint( diff_lat / FG_BUCKET_SPAN );
+#else
+    if ( diff_lat > 0 ) {
+	*dy = (int)( diff_lat / FG_BUCKET_SPAN + 0.5 );
+    } else {
+	*dy = (int)( diff_lat / FG_BUCKET_SPAN - 0.5 );
+    }
+#endif
+
+    // longitude difference
+    double c1_lon = b1.get_center_lon();
+    double c2_lon = b2.get_center_lon();
+    double diff_lon = c2_lon - c1_lon;
+    double span;
+    if ( bucket_span(c1_lat) <= bucket_span(c2_lat) ) {
+	span = bucket_span(c1_lat);
+    } else {
+	span = bucket_span(c2_lat);
+    }
+
+#ifdef HAVE_RINT
+    *dx = (int)rint( diff_lon / span );
+#else
+    if ( diff_lon > 0 ) {
+	*dx = (int)( diff_lon / span + 0.5 );
+    } else {
+	*dx = (int)( diff_lon / span - 0.5 );
+    }
+#endif
+}
+
+
+// $Log$
+// Revision 1.4  1999/03/27 05:34:05  curt
+// Elimitated some const warnings from the compiler.
+//
+// Revision 1.3  1999/02/26 22:07:54  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.2  1999/02/11 01:09:33  curt
+// Added a routine to calculate the offset in bucket units between two buckets.
+//
+// Revision 1.1  1999/02/08 23:52:16  curt
+// Added a new "newbucket.[ch]xx" FGBucket class to replace the old
+// fgBUCKET struct and C routines.  This FGBucket class adjusts the tile
+// width towards the poles to ensure the tiles are at least 8 miles wide.
+//
+
@@ -0,0 +1,360 @@
+/**************************************************************************
+ * newbucket.hxx -- new bucket routines for better world modeling
+ *
+ * Written by Curtis L. Olson, started February 1999.
+ *
+ * Copyright (C) 1999  Curtis L. Olson - curt@flightgear.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ * (Log is kept at end of this file)
+ **************************************************************************/
+
+
+#ifndef _NEWBUCKET_HXX
+#define _NEWBUCKET_HXX
+
+#include <Include/compiler.h>
+
+#include STL_STRING
+
+#ifdef FG_HAVE_STD_INCLUDES
+#  include <cstdio> // sprintf()
+#  include <iostream>
+#else
+#  include <stdio.h> // sprintf()
+#  include <iostream.h>
+#endif
+
+FG_USING_STD(string);
+FG_USING_STD(ostream);
+
+#include <Include/fg_constants.h>
+
+
+#define FG_BUCKET_SPAN      0.125   // 1/8 of a degree
+#define FG_HALF_BUCKET_SPAN 0.0625  // 1/2 of 1/8 of a degree = 1/16 = 0.0625
+
+class FGBucket;
+ostream& operator<< ( ostream&, const FGBucket& );
+bool operator== ( const FGBucket&, const FGBucket& );
+
+class FGBucket {
+
+private:
+    double cx, cy;  // centerpoint (lon, lat) in degrees of bucket
+    int lon;        // longitude index (-180 to 179)
+    int lat;        // latitude index (-90 to 89)
+    int x;          // x subdivision (0 to 7)
+    int y;          // y subdivision (0 to 7)
+
+public:
+    
+    // default constructor
+    FGBucket();
+
+    // create a bucket which would contain the specified lon/lat
+    FGBucket(const double lon, const double lat);
+
+    // create a bucket based on "long int" index
+    FGBucket(const long int bindex);
+
+    // create an impossible bucket if false
+    FGBucket(const bool is_good);
+
+    ~FGBucket();
+
+    // Set the bucket params for the specified lat and lon
+    void set_bucket( double dlon, double dlat );
+
+    // Generate the unique scenery tile index for this bucket
+    long int gen_index();
+    string gen_index_str() const;
+
+    // Build the path name for this bucket
+    string gen_base_path() const;
+
+    // return the center lon of a tile
+    double get_center_lon() const;
+
+    // return width of the tile
+    double get_width() const;
+
+    // return the center lat of a tile
+    double get_center_lat() const;
+
+    // return height of the tile
+    double get_height() const;
+
+    // Informational methods
+    inline int get_lon() const { return lon; }
+    inline int get_lat() const { return lat; }
+    inline int get_x() const { return x; }
+    inline int get_y() const { return y; }
+
+    // friends
+    friend ostream& operator<< ( ostream&, const FGBucket& );
+    friend bool operator== ( const FGBucket&, const FGBucket& );
+};
+
+
+// return the horizontal tile span factor based on latitude
+inline double bucket_span( double l ) {
+    if ( l >= 89.0 ) {
+	return 0.0;
+    } else if ( l >= 88.0 ) {
+	return 8.0;
+    } else if ( l >= 86.0 ) {
+	return 4.0;
+    } else if ( l >= 83.0 ) {
+	return 2.0;
+    } else if ( l >= 76.0 ) {
+	return 1.0;
+    } else if ( l >= 62.0 ) {
+	return 0.5;
+    } else if ( l >= 22.0 ) {
+	return 0.25;
+    } else if ( l >= -22.0 ) {
+	return 0.125;
+    } else if ( l >= -62.0 ) {
+	return 0.25;
+    } else if ( l >= -76.0 ) {
+	return 0.5;
+    } else if ( l >= -83.0 ) {
+	return 1.0;
+    } else if ( l >= -86.0 ) {
+	return 2.0;
+    } else if ( l >= -88.0 ) {
+	return 4.0;
+    } else if ( l >= -89.0 ) {
+	return 8.0;
+    } else {
+	return 0.0;
+    }
+}
+
+
+// Set the bucket params for the specified lat and lon
+inline void FGBucket::set_bucket( double dlon, double dlat ) {
+    //
+    // latitude first
+    //
+    double span = bucket_span( dlat );
+    double diff = dlon - (double)(int)dlon;
+
+    // cout << "diff = " << diff << "  span = " << span << endl;
+
+    if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
+	lon = (int)dlon;
+    } else {
+	lon = (int)dlon - 1;
+    }
+
+    // find subdivision or super lon if needed
+    if ( span < FG_EPSILON ) {
+	// polar cap
+	lon = 0;
+	x = 0;
+    } else if ( span <= 1.0 ) {
+	x = (int)((dlon - lon) / span);
+    } else {
+	if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
+	    lon = (int)( (int)(lon / span) * span);
+	} else {
+	    // cout << " lon = " << lon 
+	    //  << "  tmp = " << (int)((lon-1) / span) << endl;
+	    lon = (int)( (int)((lon + 1) / span) * span - span);
+	    if ( lon < -180 ) {
+		lon = -180;
+	    }
+	}
+	x = 0;
+    }
+
+    //
+    // then latitude
+    //
+    diff = dlat - (double)(int)dlat;
+
+    if ( (dlat >= 0) || (fabs(diff) < FG_EPSILON) ) {
+	lat = (int)dlat;
+    } else {
+	lat = (int)dlat - 1;
+    }
+    y = (int)((dlat - lat) * 8);
+}
+
+
+// default constructor
+inline FGBucket::FGBucket() {}
+
+
+// constructor for specified location
+inline FGBucket::FGBucket(const double dlon, const double dlat) {
+    set_bucket(dlon, dlat);
+}
+
+// create an impossible bucket if false
+inline FGBucket::FGBucket(const bool is_good) {
+    set_bucket(0.0, 0.0);
+    if ( !is_good ) {
+	lon = -1000;
+    }
+}
+    
+
+// Parse a unique scenery tile index and find the lon, lat, x, and y
+inline FGBucket::FGBucket(const long int bindex) {
+    long int index = bindex;
+
+    lon = index >> 14;
+    index -= lon << 14;
+    lon -= 180;
+    
+    lat = index >> 6;
+    index -= lat << 6;
+    lat -= 90;
+    
+    y = index >> 3;
+    index -= y << 3;
+
+    x = index;
+}
+
+
+// default destructor
+inline FGBucket::~FGBucket() {}
+
+
+// Generate the unique scenery tile index for this bucket
+// 
+// The index is constructed as follows:
+// 
+// 9 bits - to represent 360 degrees of longitude (-180 to 179)
+// 8 bits - to represent 180 degrees of latitude (-90 to 89)
+//
+// Each 1 degree by 1 degree tile is further broken down into an 8x8
+// grid.  So we also need:
+//
+// 3 bits - to represent x (0 to 7)
+// 3 bits - to represent y (0 to 7)
+
+inline long int FGBucket::gen_index() {
+    return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
+}
+
+inline string FGBucket::gen_index_str() const {
+    char tmp[20];
+    sprintf(tmp, "%ld", 
+	    (((long)lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x);
+    return (string)tmp;
+}
+
+
+// return the center lon of a tile
+inline double FGBucket::get_center_lon() const {
+    double span = bucket_span( lat + y / 8.0 + FG_HALF_BUCKET_SPAN );
+
+    if ( span >= 1.0 ) {
+	return lon + span / 2.0;
+    } else {
+	return lon + x * span + span / 2.0;
+    }
+}
+
+
+// return width of the tile
+inline double FGBucket::get_width() const {
+    return bucket_span( get_center_lat() );
+}
+
+
+// return the center lat of a tile
+inline double FGBucket::get_center_lat() const {
+    return lat + y / 8.0 + FG_HALF_BUCKET_SPAN;
+}
+
+
+// return height of the tile
+inline double FGBucket::get_height() const {
+    return FG_BUCKET_SPAN;
+}
+
+
+// offset a bucket struct by the specified tile units in the X & Y
+// direction
+FGBucket fgBucketOffset( double dlon, double dlat, int x, int y );
+
+
+// calculate the offset between two buckets
+void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy );
+
+
+/*
+// Given a lat/lon, fill in the local tile index array
+void fgBucketGenIdxArray(fgBUCKET *p1, fgBUCKET *tiles, int width, int height);
+*/
+
+
+inline ostream&
+operator<< ( ostream& out, const FGBucket& b )
+{
+    return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
+}
+
+
+inline bool
+operator== ( const FGBucket& b1, const FGBucket& b2 )
+{
+    return ( b1.lon == b2.lon &&
+	     b1.lat == b2.lat &&
+	     b1.x == b2.x &&
+	     b1.y == b2.y );
+}
+
+
+#endif // _NEWBUCKET_HXX
+
+
+// $Log$
+// Revision 1.8  1999/03/27 05:34:06  curt
+// Elimitated some const warnings from the compiler.
+//
+// Revision 1.7  1999/03/25 19:01:51  curt
+// Jettisoned old bucketutils.[ch] for newbucket.[ch]xx
+//
+// Revision 1.6  1999/03/15 17:58:41  curt
+// MSVC++ portability tweaks contributed by Bernie Bright.
+//   Added using std::ostream declaration.
+//   Added forward declarations to work around a MSVC bug.
+//
+// Revision 1.5  1999/03/12 22:51:18  curt
+// Added some informational methods.
+//
+// Revision 1.4  1999/03/02 01:01:43  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.3  1999/02/26 22:07:55  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.2  1999/02/11 01:09:34  curt
+// Added a routine to calculate the offset in bucket units between two buckets.
+//
+// Revision 1.1  1999/02/08 23:52:16  curt
+// Added a new "newbucket.[ch]xx" FGBucket class to replace the old
+// fgBUCKET struct and C routines.  This FGBucket class adjusts the tile
+// width towards the poles to ensure the tiles are at least 8 miles wide.
+//
@@ -0,0 +1,32 @@
+// test new bucket routines
+
+#include "newbucket.cxx"
+
+main() {
+    double lat = 21.9625;
+    double lon = -110.0 + 0.0625;
+
+    /*
+    while ( lon < 180 ) {
+	FGBucket b1( lon, lat );
+	long int index = b1.gen_index();
+	FGBucket b2( index );
+
+	cout << lon << "," << lat << "  ";
+	cout << b2 << " " << b2.get_center_lon() << "," 
+	     << b2.get_center_lat() << endl;
+
+	lon += 0.125;
+    }
+    */
+
+    FGBucket b1;
+
+    for ( int j = 2; j >= -2; j-- ) {
+	for ( int i = -2; i < 3; i++ ) {
+	    b1 = fgBucketOffset(lon, lat, i, j);
+	    cout << "(" << i << "," << j << ")" << b1 << "\t";
+	}
+	cout << endl;
+    }
+}
@@ -0,0 +1,13 @@
+# The "checkoutlist" file is used to support additional version controlled
+# administrative files in $CVSROOT/CVSROOT, such as template files.
+#
+# The first entry on a line is a filename which will be checked out from
+# the corresponding RCS file in the $CVSROOT/CVSROOT directory.
+# The remainder of the line is an error message to use if the file cannot
+# be checked out.
+#
+# File format:
+#
+#	[<whitespace>]<filename><whitespace><error message><end-of-line>
+#
+# comment lines begin with '#'
@@ -0,0 +1,15 @@
+# The "commitinfo" file is used to control pre-commit checks.
+# The filter on the right is invoked with the repository and a list 
+# of files to check.  A non-zero exit of the filter program will 
+# cause the commit to be aborted.
+#
+# The first entry on a line is a regular expression which is tested
+# against the directory that the change is being committed to, relative
+# to the $CVSROOT.  For the first match that is found, then the remainder
+# of the line is the name of the filter to run.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".
@@ -0,0 +1,22 @@
+# This file describes wrappers and other binary files to CVS.
+#
+# Wrappers are the concept where directories of files are to be
+# treated as a single file.  The intended use is to wrap up a wrapper
+# into a single tar such that the tar archive can be treated as a
+# single binary file in CVS.
+#
+# To solve the problem effectively, it was also necessary to be able to
+# prevent rcsmerge from merging these files.
+#
+# Format of wrapper file ($CVSROOT/CVSROOT/cvswrappers or .cvswrappers)
+#
+#  wildcard	[option value][option value]...
+#
+#  where option is one of
+#  -f		from cvs filter		value: path to filter
+#  -t		to cvs filter		value: path to filter
+#  -m		update methodology	value: MERGE or COPY
+#
+#  and value is a single-quote delimited value.
+#
+# For example:
@@ -0,0 +1,21 @@
+# The "editinfo" file is used to allow verification of logging
+# information.  It works best when a template (as specified in the
+# rcsinfo file) is provided for the logging procedure.  Given a
+# template with locations for, a bug-id number, a list of people who
+# reviewed the code before it can be checked in, and an external
+# process to catalog the differences that were code reviewed, the
+# following test can be applied to the code:
+#
+#   Making sure that the entered bug-id number is correct.
+#   Validating that the code that was reviewed is indeed the code being
+#       checked in (using the bug-id number or a seperate review
+#       number to identify this particular code set.).
+#
+# If any of the above test failed, then the commit would be aborted.
+#
+# Actions such as mailing a copy of the report to each reviewer are
+# better handled by an entry in the loginfo file.
+#
+# One thing that should be noted is the the ALL keyword is not
+# supported.  There can be only one entry that matches a given
+# repository.
@@ -0,0 +1,19 @@
+# The "loginfo" file is used to control where "cvs commit" log information is
+# sent.  The first entry on a line is a regular expression which is tested
+# against the directory that the change is being made to, relative to the
+# $CVSROOT.  For the first match that is found, the remainder of the line is a
+# filter program that should expect log information on its standard input
+#
+# If the repository name does not match any of the regular expressions in the
+# first field of this file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".
+#
+# The filter program may use one and only one "%s" modifier (ala printf).  If
+# such a "%s" is specified in the filter program, a brief title is included
+# (as one argument, enclosed in single quotes) showing the relative directory
+# name and listing the modified file names.
+#
+# For example:
+#DEFAULT		(echo ""; who am i; echo %s; date; cat) >> $CVSROOT/CVSROOT/commitlog
@@ -0,0 +1,26 @@
+# Three different line formats are valid:
+#	key	-a    aliases...
+#	key [options] directory
+#	key [options] directory files...
+#
+# Where "options" are composed of:
+#	-i prog		Run "prog" on "cvs commit" from top-level of module.
+#	-o prog		Run "prog" on "cvs checkout" of module.
+#	-e prog		Run "prog" on "cvs export" of module.
+#	-t prog		Run "prog" on "cvs rtag" of module.
+#	-u prog		Run "prog" on "cvs update" of module.
+#	-d dir		Place module in directory "dir" instead of module name.
+#	-l		Top-level directory only -- do not recurse.
+#
+# NOTE:  If you change any of the "Run" options above, you'll have to
+# release and re-checkout any working directories of these modules.
+#
+# And "directory" is a path to a directory relative to $CVSROOT.
+#
+# The "-a" option specifies an alias.  An alias is interpreted as if
+# everything on the right of the "-a" had been typed on the command line.
+#
+# You can encode a module within a module by using the special '&'
+# character to interpose another module into the current module.  This
+# can be useful for creating a module that consists of many directories
+# spread out over the entire source repository.
@@ -0,0 +1,12 @@
+# The "notify" file controls where notifications from watches set by
+# "cvs watch add" or "cvs edit" are sent.  The first entry on a line is
+# a regular expression which is tested against the directory that the
+# change is being made to, relative to the $CVSROOT.  If it matches,
+# then the remainder of the line is a filter program that should contain
+# one occurrence of %s for the user to notify, and information on its
+# standard input.
+#
+# "ALL" or "DEFAULT" can be used in place of the regular expression.
+#
+# For example:
+#ALL mail %s -s "CVS notification"
@@ -0,0 +1,13 @@
+# The "rcsinfo" file is used to control templates with which the editor
+# is invoked on commit and import.
+#
+# The first entry on a line is a regular expression which is tested
+# against the directory that the change is being made to, relative to the
+# $CVSROOT.  For the first match that is found, then the remainder of the
+# line is the name of the file that contains the template.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".
@@ -0,0 +1,20 @@
+# The "taginfo" file is used to control pre-tag checks.
+# The filter on the right is invoked with the following arguments:
+#
+# $1 -- tagname
+# $2 -- operation "add" for tag, "mov" for tag -F, and "del" for tag -d
+# $3 -- repository
+# $4->  file revision [file revision ...]
+#
+# A non-zero exit of the filter program will cause the tag to be aborted.
+#
+# The first entry on a line is a regular expression which is tested
+# against the directory that the change is being committed to, relative
+# to the $CVSROOT.  For the first match that is found, then the remainder
+# of the line is the name of the filter to run.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".
@@ -0,0 +1,11 @@
+EXTRA_DIST = logtest.cxx
+
+noinst_LIBRARIES = libDebug.a
+
+libDebug_a_SOURCES = \
+	debug_types.h \
+	logstream.cxx logstream.hxx
+
+#	fg_debug.c fg_debug.h \
+
+INCLUDES += -I$(top_builddir)
@@ -0,0 +1,37 @@
+// NB: To add a dbg_class, add it here, and add it to the structure in
+// fg_debug.c
+
+typedef enum {
+    FG_NONE      = 0x00000000,
+
+    FG_TERRAIN   = 0x00000001,
+    FG_ASTRO     = 0x00000002,
+    FG_FLIGHT    = 0x00000004,
+    FG_INPUT     = 0x00000008,
+    FG_GL        = 0x00000010,
+    FG_VIEW      = 0x00000020,
+    FG_COCKPIT   = 0x00000040,
+    FG_GENERAL   = 0x00000080,
+    FG_MATH      = 0x00000100,
+    FG_EVENT     = 0x00000200,
+    FG_AIRCRAFT  = 0x00000400,
+    FG_AUTOPILOT = 0x00000800,
+    FG_SERIAL    = 0x00001000,
+    FG_CLIPPER   = 0x00002000,
+    FG_UNDEFD    = 0x00004000, // For range checking
+
+    FG_ALL     = 0xFFFFFFFF
+} fgDebugClass;
+
+
+// NB: To add a priority, add it here.
+typedef enum {
+    FG_BULK,	    // For frequent messages
+    FG_DEBUG, 	    // Less frequent debug type messages
+    FG_INFO,        // Informatory messages
+    FG_WARN,	    // Possible impending problem
+    FG_ALERT       // Very possible impending problem
+    // FG_EXIT,        // Problem (no core)
+    // FG_ABORT        // Abandon ship (core)
+} fgDebugPriority;
+
@@ -0,0 +1,310 @@
+/* -*- Mode: C++ -*-
+ *
+ * fg_debug.c -- Flight Gear debug utility functions
+ *
+ * Written by Paul Bleisch, started January 1998. 
+ *
+ * Copyright (C) 1998 Paul Bleisch, pbleisch@acm.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ * (Log is kept at end of this file)
+ **************************************************************************/
+
+
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include <Include/cmdargs.h> // Line to command line arguments
+
+#include "fg_debug.h"
+
+
+static int             fg_DebugSem      = 1;
+fgDebugClass           fg_DebugClass    = FG_NONE;  // Need visibility for
+fgDebugPriority        fg_DebugPriority = FG_INFO; // command line processing.
+static fgDebugCallback fg_DebugCallback = NULL;
+
+FILE *fg_DebugOutput = NULL;  // Visibility needed for command line processor.
+                              // This can be set to a FILE from the command
+                              // line. If not, it will be set to stderr.
+
+/* TODO: Actually make this thing thread safe */
+#ifdef USETHREADS
+#define FG_GRABDEBUGSEM  while( --fg_DebugSem < 0 ) { fg_DebugSem++; }
+#define FG_RELEASEDEBUGSEM fg_DebugSem++;
+#else
+#define FG_GRABDEBUGSEM
+#define FG_RELEASEDEBUGSEM
+#endif
+
+/* Used for convienence initialization from env variables.
+ */
+static struct {
+    char *str;
+    fgDebugClass dbg_class;
+} fg_DebugClasses[] = {
+    { "FG_NONE",      0x00000000 },
+    { "FG_TERRAIN",   0x00000001 },
+    { "FG_ASTRO",     0x00000002 },
+    { "FG_FLIGHT",    0x00000004 },
+    { "FG_INPUT",     0x00000008 },
+    { "FG_GL",        0x00000010 },
+    { "FG_VIEW",      0x00000020 },
+    { "FG_COCKPIT",   0x00000040 },
+    { "FG_GENERAL",   0x00000080 },
+    { "FG_MATH",      0x00000100 },
+    { "FG_EVENT",     0x00000200 },
+    { "FG_AIRCRAFT",  0x00000400 },
+    { "FG_AUTOPILOT", 0x00000800 },
+
+    /* Do not edit below here, last entry should be null */
+    { "FG_ALL",       0xFFFFFFFF },
+    { NULL, 0 } 
+};
+
+static fgDebugClass fgDebugStrToClass( char *str );
+
+
+/* fgInitDebug =============================================================*/
+void fgInitDebug( void ) {
+    char *pszClass, *pszPrio, *pszFile;
+
+    // Support for log file/alt debug output via command line, environment or
+    // reasonable default.
+
+    /*
+    if( strlen( logArgbuf ) > 3) {   // First check for command line option
+	// Assumed that we will append.
+	fg_DebugOutput = fopen(logArgbuf, "a+" );
+    }
+    */
+
+    if( !fg_DebugOutput ) {          // If not set on command line, environment?
+	pszFile = getenv( "FG_DEBUGFILE" );
+	if( pszFile ) {          // There is such an environmental variable.
+	    fg_DebugOutput = fopen( pszFile, "a+" );
+	}
+    }
+
+    if( !fg_DebugOutput ) {         // If neither command line nor environment
+	fg_DebugOutput = stderr;      // then we use the fallback position
+    }
+    
+    FG_GRABDEBUGSEM;
+    fg_DebugSem = fg_DebugSem;  /* shut up GCC */
+
+    // Test command line option overridge of debug priority. If the value
+    // is in range (properly optioned) the we will override both defaults
+    // and the environmental value.
+
+    /*
+    if ((priorityArgValue >= FG_BULK) && (priorityArgValue <= FG_ABORT)) {
+	fg_DebugPriority = priorityArgValue;
+    } else {  // Either not set or out of range. We will not warn the user.
+    */
+	pszPrio = getenv( "FG_DEBUGPRIORITY" );
+	if( pszPrio ) {
+	    fg_DebugPriority = atoi( pszPrio );
+	    fprintf( stderr,
+		     "fg_debug.c: Environment overrides default debug priority (%d)\n",
+		     fg_DebugPriority );
+	}
+    /* } */
+
+
+    /*
+    if ((debugArgValue >= FG_ALL) && (debugArgValue < FG_UNDEFD)) {
+	fg_DebugPriority = priorityArgValue;
+    } else {  // Either not set or out of range. We will not warn the user.
+    */
+	pszClass = getenv( "FG_DEBUGCLASS" );
+	if( pszClass ) {
+	    fg_DebugClass = fgDebugStrToClass( pszClass );
+	    fprintf( stderr,
+		     "fg_debug.c: Environment overrides default debug class (0x%08X)\n",
+		     fg_DebugClass );
+	}
+    /* } */
+
+    FG_RELEASEDEBUGSEM;
+}
+
+/* fgDebugStrToClass ======================================================*/
+fgDebugClass fgDebugStrToClass( char *str ) {
+    char *hex = "0123456789ABCDEF";
+    char *hexl = "0123456789abcdef";
+    char *pt, *p, *ph, ps = 1;
+    unsigned int val = 0, i;
+  
+    if( str == NULL ) {
+	return 0;
+    }
+
+    /* Check for 0xXXXXXX notation */
+    p = strstr( str, "0x");
+    if( p ) {
+	p++; p++;
+	while (*p) {
+	    ph = strchr(hex,*p);
+	    if ( ph ) {
+ 		val <<= 4;
+		val += ph-hex;
+		p++;
+	    } else {
+		ph = strchr(hexl,*p);
+		if ( ph ) {
+		    val <<= 4;
+		    val += ph-hex;
+		    p++;
+		} else {
+		    // fprintf( stderr, "Error in hex string '%s'\n", str ); 
+		    return FG_NONE;
+		}
+	    }
+	}
+    } else {
+	/* Must be in string format */
+	p = str;
+	ps = 1;
+	while( ps ) {
+	    while( *p && (*p==' ' || *p=='\t') ) p++; /* remove whitespace */
+	    pt = p; /* mark token */
+	    while( *p && (*p!='|') ) p++; /* find OR or EOS */
+	    ps = *p; /* save value at p so we can attempt to be bounds safe */
+	    *p++ = 0; /* terminate token */
+	    /* determine value for token */
+	    i=0; 
+	    while( fg_DebugClasses[i].str && 
+		   strncmp( fg_DebugClasses[i].str, pt, 
+			    strlen(fg_DebugClasses[i].str)) ) i++;
+	    if( fg_DebugClasses[i].str == NULL ) {
+		fprintf( stderr,
+			 "fg_debug.c: Could not find message class '%s'\n",
+			 pt ); 
+	    } else {
+		val |= fg_DebugClasses[i].dbg_class;
+	    }
+	}
+    }
+    return (fgDebugClass)val;
+}
+
+
+/* fgSetDebugOutput =======================================================*/
+void fgSetDebugOutput( FILE *out ) {
+    FG_GRABDEBUGSEM;
+    fflush( fg_DebugOutput );
+    fg_DebugOutput = out;
+    FG_RELEASEDEBUGSEM;
+}
+
+
+/* fgSetDebugLevels =======================================================*/
+void fgSetDebugLevels( fgDebugClass dbg_class, fgDebugPriority prio ) {
+    FG_GRABDEBUGSEM;
+    fg_DebugClass = dbg_class;
+    fg_DebugPriority = prio;
+    FG_RELEASEDEBUGSEM;
+}
+
+
+/* fgRegisterDebugCallback ================================================*/
+fgDebugCallback fgRegisterDebugCallback( fgDebugCallback callback ) {
+    fgDebugCallback old;
+    FG_GRABDEBUGSEM;
+    old = fg_DebugCallback;
+    fg_DebugCallback = callback;
+    FG_RELEASEDEBUGSEM;
+    return old;
+}
+
+
+/* fgPrintf ===============================================================*/
+int fgPrintf( fgDebugClass dbg_class, fgDebugPriority prio, char *fmt, ... ) {
+    char szOut[1024+1];
+    va_list ap;
+    int ret = 0;
+
+    // If no action to take, then don't bother with the semaphore
+    // activity Slight speed benefit.
+
+    // printf("dbg_class = %d  fg_DebugClass = %d\n", dbg_class, fg_DebugClass);
+    // printf("prio = %d  fg_DebugPriority = %d\n", prio, fg_DebugPriority);
+
+    if( !(dbg_class & fg_DebugClass) ) {
+	// Failed to match a specific debug class
+	if ( prio < fg_DebugPriority ) {
+	    // priority is less than requested
+
+	    // "ret" is zero anyway. But we might think about changing
+	    // it upon some error condition?
+	    return ret;
+	}
+    }
+
+    FG_GRABDEBUGSEM;
+
+    /* ret = vsprintf( szOut, fmt, (&fmt+1)); (but it didn't work, thus ... */
+    va_start (ap, fmt);
+    ret = vsprintf( szOut, fmt, ap);
+    va_end (ap);
+
+    if( fg_DebugCallback!=NULL && fg_DebugCallback(dbg_class, prio, szOut) ) {
+	FG_RELEASEDEBUGSEM;
+	return ret;
+    } else {
+	fprintf( fg_DebugOutput, szOut );
+	FG_RELEASEDEBUGSEM;
+	if( prio == FG_EXIT ) {
+	    exit(0);
+	} else if( prio == FG_ABORT ) {
+	    abort();
+	}
+    }
+    return ret;  
+}
+
+
+/* $Log$
+/* Revision 1.4  1998/06/01 17:49:44  curt
+/* Rewrote a slightly ambiguous code fragment (contributed by Charlie Hotchkiss)
+/*
+ * Revision 1.3  1998/05/07 23:03:54  curt
+ * Added an entry for AUTOPILOT.
+ *
+ * Revision 1.2  1998/04/21 17:03:45  curt
+ * Prepairing for C++ integration.
+ *
+ * Revision 1.1  1998/04/18 03:52:04  curt
+ * Moved to Lib directory and created a libDebug.
+ *
+ * Revision 1.10  1998/03/14 00:31:21  curt
+ * Beginning initial terrain texturing experiments.
+ *
+ * Revision 1.9  1998/03/09 22:44:58  curt
+ * Modified so that you can specify FG_DEBUGCLASS ***or*** FG_DEBUG_PRIORITY
+ *
+ * Revision 1.8  1998/03/09 22:11:00  curt
+ * Processed through the format-o-matic.
+ *
+ * Revision 1.7  1998/02/16 13:39:43  curt
+ * Miscellaneous weekend tweaks.  Fixed? a cache problem that caused whole
+ * tiles to occasionally be missing.
+ *
+ */
@@ -0,0 +1,156 @@
+/* -*- Mode: C++ -*-
+ *
+ * fg_debug.h -- Flight Gear debug utility functions
+ *
+ * Written by Paul Bleisch, started January 1998. 
+ *
+ * Copyright (C) 1998 Paul Bleisch, pbleisch@acm.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * (Log is kept at end of this file)
+ **************************************************************************/
+
+#error "use logstream"
+
+#ifndef _FG_DEBUG_H
+#define _FG_DEBUG_H
+
+#ifdef __cplusplus                                                          
+extern "C" {                            
+#endif                                   
+
+
+#include <stdio.h>
+
+/* NB: To add a dbg_class, add it here, and add it to the structure in
+   fg_debug.c */
+typedef enum {
+    FG_NONE      = 0x00000000,
+
+    FG_TERRAIN   = 0x00000001,
+    FG_ASTRO     = 0x00000002,
+    FG_FLIGHT    = 0x00000004,
+    FG_INPUT     = 0x00000008,
+    FG_GL        = 0x00000010,
+    FG_VIEW      = 0x00000020,
+    FG_COCKPIT   = 0x00000040,
+    FG_GENERAL   = 0x00000080,
+    FG_MATH      = 0x00000100,
+    FG_EVENT     = 0x00000200,
+    FG_AIRCRAFT  = 0x00000400,
+    FG_AUTOPILOT = 0x00000800,
+    FG_UNDEFD    = 0x00001000, // For range checking
+
+    FG_ALL     = 0xFFFFFFFF
+} fgDebugClass;
+
+/* NB: To add a priority, add it here. */
+typedef enum  {
+    FG_BULK,	    /* For frequent messages */
+    FG_DEBUG, 	    /* Less frequent debug type messages */
+    FG_INFO,          /* Informatory messages */
+    FG_WARN,	    /* Possible impending problem */
+    FG_ALERT,         /* Very possible impending problem */
+    FG_EXIT,          /* Problem (no core) */
+    FG_ABORT          /* Abandon ship (core) */
+} fgDebugPriority;
+
+
+/* Initialize the debuggin stuff. */
+void fgInitDebug( void );
+
+
+/* fgPrintf
+
+   Expects:
+   class      fgDebugClass mask for this message.
+   prio       fgDebugPriority of this message.
+   fmt        printf like string format
+   ...        var args for fmt
+
+   Returns:
+   number of items in fmt handled.
+
+   This function works like the standard C library function printf() with
+   the addition of message classes and priorities (see fgDebugClasses
+   and fgDebugPriorities).  These additions allow us to classify messages
+   and disable sets of messages at runtime.  Only messages with a prio
+   greater than or equal to fg_DebugPriority and in the current debug class 
+   (fg_DebugClass) are printed.
+*/
+int fgPrintf( fgDebugClass dbg_class, fgDebugPriority prio, char *fmt, ... ); 
+
+
+/* fgSetDebugLevels()
+
+   Expects:
+   dbg_class      Bitmask representing classes to display.
+   prio       Minimum priority of messages to display.
+*/
+void fgSetDebugLevels( fgDebugClass dbg_class, fgDebugPriority prio );
+
+/* fgSetDebugOutput()
+
+   Expects:
+   file       A FILE* to a stream to send messages to.  
+
+   It is assumed the file stream is open and writable.  The system
+   defaults to stderr.  The current stream is flushed but not
+   closed.
+*/
+void fgSetDebugOutput( FILE *out );
+
+
+/* fgRegisterDebugCallback
+
+   Expects:
+   callback   A function that takes parameters as defined by the 
+              fgDebugCallback type.
+
+   Returns:
+   a pointer to the previously registered callback (if any)
+  
+   Install a user defined debug log callback.   This callback is called w
+   whenever fgPrintf is called.  The parameters passed to the callback are
+   defined above by fgDebugCallback.  outstr is the string that is to be
+   printed.  If callback returns nonzero, it is assumed that the message
+   was handled fully by the callback and **fgPrintf need do no further 
+   processing of the message.**  Only one callback may be installed at a 
+   time.
+*/
+
+//typedef int (*fgDebugCallback)(fgDebugClass, fgDebugPriority, char *outstr);
+//fgDebugCallback fgRegisterDebugCallback( fgDebugCallback callback );
+
+typedef int (*fgDebugCallback)( int DebugClass, int DebugPriority, char *outstr);
+fgDebugCallback fgRegisterDebugCallback( fgDebugCallback callback );
+
+
+// Leave these alone. Access intended for fg_debug and command line processing.
+//
+extern fgDebugClass    fg_DebugClass;
+extern fgDebugPriority fg_DebugPriority;
+
+extern FILE *          fg_DebugOutput;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _FG_DEBUG_H */
+
@@ -0,0 +1,71 @@
+// Stream based logging mechanism.
+//
+// Written by Bernie Bright, 1998
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#include "logstream.hxx"
+
+bool            logbuf::logging_enabled = true;
+fgDebugClass    logbuf::logClass        = FG_NONE;
+fgDebugPriority logbuf::logPriority     = FG_INFO;
+streambuf*      logbuf::sbuf            = NULL;
+
+logbuf::logbuf()
+{
+//     if ( sbuf == NULL )
+// 	sbuf = cerr.rdbuf();
+}
+
+logbuf::~logbuf()
+{
+    if ( sbuf )
+	    sync();
+}
+
+void
+logbuf::set_sb( streambuf* sb )
+{
+    if ( sbuf )
+	    sync();
+
+    sbuf = sb;
+}
+
+void
+logbuf::set_log_level( fgDebugClass c, fgDebugPriority p )
+{
+    logClass = c;
+    logPriority = p;
+}
+
+void
+logstream::setLogLevels( fgDebugClass c, fgDebugPriority p )
+{
+    logbuf::set_log_level( c, p );
+}
+
+// $Log$
+// Revision 1.2  1999/01/19 20:53:34  curt
+// Portability updates by Bernie Bright.
+//
+// Revision 1.1  1998/11/06 21:20:41  curt
+// Initial revision.
+//
@@ -0,0 +1,228 @@
+// Stream based logging mechanism.
+//
+// Written by Bernie Bright, 1998
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#ifndef _LOGSTREAM_H
+#define _LOGSTREAM_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+
+#include <Include/compiler.h>
+
+#ifdef FG_HAVE_STD_INCLUDES
+# include <streambuf>
+# include <iostream>
+#else
+# include <iostream.h>
+# include "Include/fg_traits.hxx"
+#endif
+
+#include "debug_types.h"
+
+#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
+FG_USING_STD(streambuf);
+FG_USING_STD(ostream);
+FG_USING_STD(cerr);
+FG_USING_STD(endl);
+#endif
+
+//
+// TODO:
+//
+// 1. Change output destination. Done.
+// 2. Make logbuf thread safe.
+// 3. Read environment for default debugClass and debugPriority.
+//
+
+//-----------------------------------------------------------------------------
+//
+// logbuf is an output-only streambuf with the ability to disable sets of
+// messages at runtime. Only messages with priority >= logbuf::logPriority
+// and debugClass == logbuf::logClass are output.
+//
+class logbuf : public streambuf
+{
+public:
+
+#ifndef FG_HAVE_STD_INCLUDES
+    typedef char_traits<char>           traits_type;
+    typedef char_traits<char>::int_type int_type;
+    typedef char_traits<char>::pos_type pos_type;
+    typedef char_traits<char>::off_type off_type;
+#endif
+//     logbuf( streambuf* sb ) : sbuf(sb) {}
+    logbuf();
+    ~logbuf();
+
+    // Is logging enabled?
+    bool enabled() { return logging_enabled; }
+
+    // Set the logging level of subsequent messages.
+    void set_log_state( fgDebugClass c, fgDebugPriority p );
+
+    // Set the global logging level.
+    static void set_log_level( fgDebugClass c, fgDebugPriority p );
+
+    //
+    void set_sb( streambuf* sb );
+
+protected:
+
+    inline virtual int sync();
+    int_type overflow( int ch );
+//     int xsputn( const char* s, istreamsize n );
+
+private:
+
+    // The streambuf used for actual output. Defaults to cerr.rdbuf().
+    static streambuf* sbuf;
+
+    static bool logging_enabled;
+    static fgDebugClass logClass;
+    static fgDebugPriority logPriority;
+
+private:
+
+    // Not defined.
+    logbuf( const logbuf& );
+    void operator= ( const logbuf& );
+};
+
+inline int
+logbuf::sync()
+{
+#ifdef FG_HAVE_STD_INCLUDES
+	return sbuf->pubsync();
+#else
+	return sbuf->sync();
+#endif
+}
+
+inline void
+logbuf::set_log_state( fgDebugClass c, fgDebugPriority p )
+{
+    logging_enabled = ((c & logClass) != 0 && p >= logPriority);
+}
+
+inline logbuf::int_type
+logbuf::overflow( int c )
+{
+    return logging_enabled ? sbuf->sputc(c) : (EOF == 0 ? 1: 0);
+}
+
+//-----------------------------------------------------------------------------
+//
+// logstream manipulator for setting the log level of a message.
+//
+struct loglevel
+{
+    loglevel( fgDebugClass c, fgDebugPriority p )
+	: logClass(c), logPriority(p) {}
+
+    fgDebugClass logClass;
+    fgDebugPriority logPriority;
+};
+
+//-----------------------------------------------------------------------------
+//
+// A helper class that ensures a streambuf and ostream are constructed and
+// destroyed in the correct order.  The streambuf must be created before the
+// ostream but bases are constructed before members.  Thus, making this class
+// a private base of logstream, declared to the left of ostream, we ensure the
+// correct order of construction and destruction.
+//
+struct logstream_base
+{
+//     logstream_base( streambuf* sb ) : lbuf(sb) {}
+    logstream_base() {}
+
+    logbuf lbuf;
+};
+
+//-----------------------------------------------------------------------------
+//
+// 
+//
+class logstream : private logstream_base, public ostream
+{
+public:
+    // The default is to send messages to cerr.
+    logstream( ostream& out )
+// 	: logstream_base(out.rdbuf()),
+	: logstream_base(),
+	  ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
+
+    void set_output( ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
+
+    // Set the global log class and priority level.
+     void setLogLevels( fgDebugClass c, fgDebugPriority p );
+
+    // Output operator to capture the debug level and priority of a message.
+    inline ostream& operator<< ( const loglevel& l );
+};
+
+inline ostream&
+logstream::operator<< ( const loglevel& l )
+{
+    lbuf.set_log_state( l.logClass, l.logPriority );
+    return *this;
+}
+
+//-----------------------------------------------------------------------------
+//
+// Return the one and only logstream instance.
+// We use a function instead of a global object so we are assured that cerr
+// has been initialised.
+//
+inline logstream&
+fglog()
+{
+    static logstream logstrm( cerr );
+    return logstrm;
+}
+
+#ifdef FG_NDEBUG
+# define FG_LOG(C,P,M)
+#else
+# define FG_LOG(C,P,M) fglog() << loglevel(C,P) << M << endl
+#endif
+
+#endif // _LOGSTREAM_H
+
+// $Log$
+// Revision 1.4  1999/03/02 01:01:47  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.3  1999/01/19 20:53:35  curt
+// Portability updates by Bernie Bright.
+//
+// Revision 1.2  1998/11/07 19:07:02  curt
+// Enable release builds using the --without-logging option to the configure
+// script.  Also a couple log message cleanups, plus some C to C++ comment
+// conversion.
+//
+// Revision 1.1  1998/11/06 21:20:42  curt
+// Initial revision.
+//
@@ -0,0 +1,34 @@
+#include <string>
+#include "Debug/logstream.hxx"
+
+int
+main( int argc, char* argv[] )
+{
+    fglog().setLogLevels( FG_ALL, FG_INFO );
+
+    FG_LOG( FG_TERRAIN, FG_BULK,  "terrain::bulk" ); // shouldnt appear
+    FG_LOG( FG_TERRAIN, FG_DEBUG, "terrain::debug" ); // shouldnt appear
+    FG_LOG( FG_TERRAIN, FG_INFO,  "terrain::info" );
+    FG_LOG( FG_TERRAIN, FG_WARN,  "terrain::warn" );
+    FG_LOG( FG_TERRAIN, FG_ALERT, "terrain::alert" );
+
+    int i = 12345;
+    long l = 54321L;
+    double d = 3.14159;
+    string s = "Hello world!";
+
+    FG_LOG( FG_EVENT, FG_INFO, "event::info "
+				 << "i=" << i
+				 << ", l=" << l
+				 << ", d=" << d
+	                         << ", d*l=" << d*l
+				 << ", s=\"" << s << "\"" );
+
+    // This shouldn't appear in log output:
+    FG_LOG( FG_EVENT, FG_DEBUG, "event::debug "
+	    << "- this should be seen - "
+	    << "d=" << d
+	    << ", s=\"" << s << "\"" );
+
+    return 0;
+}
@@ -0,0 +1,22 @@
+if ENABLE_AUDIO_SUPPORT
+AUDIO_DIRS = Audio
+else
+AUDIO_DIRS = 
+endif
+
+if ENABLE_UNIX_SERIAL
+SERIAL_DIRS = Serial
+else
+SERIAL_DIRS =
+endif
+
+SUBDIRS = \
+	$(AUDIO_DIRS) \
+	Bucket \
+	Debug \
+	Math \
+	Misc \
+	PUI \
+	$(SERIAL_DIRS) \
+	XGL\
+	zlib
@@ -0,0 +1,168 @@
+/* #include "HEADERS.h" */
+/* Copyright 1988, Brown Computer Graphics Group.  All Rights Reserved. */
+
+/* --------------------------------------------------------------------------
+ * This file contains routines that perform geometry-related operations
+ * on matrices.
+ * -------------------------------------------------------------------------*/
+
+#include <Math/mat3defs.h>
+
+/* --------------------------  Static Routines	---------------------------- */
+
+/* -------------------------  Internal Routines  --------------------------- */
+
+/* --------------------------  Public Routines	---------------------------- */
+
+/*
+ * This takes a matrix used to transform points, and returns a corresponding
+ * matrix that can be used to transform direction vectors (between points).
+ */
+
+void
+MAT3direction_matrix(register double (*result_mat)[4], register double (*mat)[4])
+{
+   register int i;
+
+   MAT3copy(result_mat, mat);
+
+   for (i = 0; i < 4; i++) result_mat[i][3] = result_mat[3][i] = 0.0;
+
+   result_mat[3][3] = 1.0;
+}
+
+/*
+ * This takes a matrix used to transform points, and returns a corresponding
+ * matrix that can be used to transform vectors that must remain perpendicular
+ * to planes defined by the points.  It is useful when you are transforming
+ * some object that has both points and normals in its definition, and you
+ * only have the transformation matrix for the points.	This routine returns
+ * FALSE if the normal matrix is uncomputable.	Otherwise, it returns TRUE.
+ *
+ * Spike sez: "This is the adjoint for the non-homogeneous part of the
+ *	       transformation."
+ */
+
+int
+MAT3normal_matrix(register double (*result_mat)[4], register double (*mat)[4])
+{
+   register int ret;
+   MAT3mat	tmp_mat;
+
+   MAT3direction_matrix(result_mat, mat);
+
+   if ( (ret = MAT3invert(tmp_mat, tmp_mat)) ) {
+       MAT3transpose(result_mat, tmp_mat);
+   }
+
+   return(ret);
+}
+
+/*
+ * Sets the given matrix to be a scale matrix for the given vector of
+ * scale values.
+ */
+
+void
+MAT3scale(double (*result_mat)[4], double *scale)
+{
+   MAT3identity(result_mat);
+
+   result_mat[0][0] = scale[0];
+   result_mat[1][1] = scale[1];
+   result_mat[2][2] = scale[2];
+}
+
+/*
+ * Sets up a matrix for a rotation about an axis given by the line from
+ * (0,0,0) to axis, through an angle (in radians).
+ * Looking along the axis toward the origin, the rotation is counter-clockwise.
+ */
+
+#define SELECT	.7071	/* selection constant (roughly .5*sqrt(2) */
+
+void
+MAT3rotate(double (*result_mat)[4], double *axis, double angle_in_radians)
+{
+   MAT3vec	naxis,	/* Axis of rotation, normalized 		*/
+		base2,	/* 2nd unit basis vec, perp to axis		*/
+		base3;	/* 3rd unit basis vec, perp to axis & base2	*/
+   double	dot;
+   MAT3mat	base_mat,	/* Change-of-basis matrix		*/
+		base_mat_trans; /* Inverse of c-o-b matrix		*/
+   register int i;
+
+   /* Step 1: extend { axis } to a basis for 3-space: { axis, base2, base3 }
+    * which is orthonormal (all three have unit length, and all three are
+    * mutually orthogonal). Also should be oriented, i.e. axis cross base2 =
+    * base3, rather than -base3.
+    *
+    * Method: Find a vector linearly independent from axis. For this we
+    * either use the y-axis, or, if that is too close to axis, the
+    * z-axis. 'Too close' means that the dot product is too near to 1.
+    */
+
+   MAT3_COPY_VEC(naxis, axis);
+   MAT3_NORMALIZE_VEC(naxis, dot);
+
+   if (dot == 0.0) {
+       /* ERR_ERROR(MAT3_errid, ERR_SEVERE,
+		   (ERR_S, "Zero-length axis vector given to MAT3rotate")); */
+      return;
+   }
+
+   MAT3perp_vec(base2, naxis, TRUE);
+   MAT3cross_product(base3, naxis, base2);
+
+   /* Set up the change-of-basis matrix, and its inverse */
+   MAT3identity(base_mat);
+   MAT3identity(base_mat_trans);
+   MAT3identity(result_mat);
+
+   for (i = 0; i < 3; i++){
+      base_mat_trans[i][0] = base_mat[0][i] = naxis[i];
+      base_mat_trans[i][1] = base_mat[1][i] = base2[i];
+      base_mat_trans[i][2] = base_mat[2][i] = base3[i];
+   }
+
+   /* If T(u) = uR, where R is base_mat, then T(x-axis) = naxis,
+    * T(y-axis) = base2, and T(z-axis) = base3. The inverse of base_mat is
+    * its transpose.  OK?
+    */
+
+   result_mat[1][1] =	result_mat[2][2] = cos(angle_in_radians);
+   result_mat[2][1] = -(result_mat[1][2] = sin(angle_in_radians));
+
+   MAT3mult(result_mat, base_mat_trans, result_mat);
+   MAT3mult(result_mat, result_mat,	base_mat);
+}
+
+/*
+ * Sets the given matrix to be a translation matrix for the given vector of
+ * translation values.
+ */
+
+void
+MAT3translate(double (*result_mat)[4], double *trans)
+{
+   MAT3identity(result_mat);
+
+   result_mat[3][0] = trans[0];
+   result_mat[3][1] = trans[1];
+   result_mat[3][2] = trans[2];
+}
+
+/*
+ * Sets the given matrix to be a shear matrix for the given x and y shear
+ * values.
+ */
+
+void
+MAT3shear(double (*result_mat)[4], double xshear, double yshear)
+{
+   MAT3identity(result_mat);
+
+   result_mat[2][0] = xshear;
+   result_mat[2][1] = yshear;
+}
+
@@ -0,0 +1,311 @@
+/* Copyright 1988, Brown Computer Graphics Group.  All Rights Reserved. */
+
+/* --------------------------------------------------------------------------
+ * This file contains routines that operate solely on matrices.
+ * -------------------------------------------------------------------------*/
+
+#include <Math/mat3defs.h>
+
+/* --------------------------  Static Routines	---------------------------- */
+
+#define SMALL 1e-20		/* Small enough to be considered zero */
+
+/*
+ * Shuffles rows in inverse of 3x3.  See comment in MAT3_inv3_second_col().
+ */
+
+static void
+MAT3_inv3_swap( register double inv[3][3], int row0, int row1, int row2)
+{
+   register int i, tempi;
+   double	temp;
+
+#define SWAP_ROWS(a, b) \
+   for (i = 0; i < 3; i++) SWAP(inv[a][i], inv[b][i], temp); \
+   SWAP(a, b, tempi)
+
+   if (row0 != 0){
+      if (row1 == 0) {
+	 SWAP_ROWS(row0, row1);
+      }
+      else {
+	 SWAP_ROWS(row0, row2);
+      }
+   }
+
+   if (row1 != 1) {
+      SWAP_ROWS(row1, row2);
+   }
+}
+
+/*
+ * Does Gaussian elimination on second column.
+ */
+
+static int
+MAT3_inv3_second_col (register double source[3][3], register double inv[3][3], int row0)
+{
+   register int row1, row2, i1, i2, i;
+   double	temp;
+   double	a, b;
+
+   /* Find which row to use */
+   if	   (row0 == 0)	i1 = 1, i2 = 2;
+   else if (row0 == 1)	i1 = 0, i2 = 2;
+   else 		i1 = 0, i2 = 1;
+
+   /* Find which is larger in abs. val.:the entry in [i1][1] or [i2][1]	*/
+   /* and use that value for pivoting.					*/
+
+   a = source[i1][1]; if (a < 0) a = -a;
+   b = source[i2][1]; if (b < 0) b = -b;
+   if (a > b) 	row1 = i1;
+   else		row1 = i2;
+   row2 = (row1 == i1 ? i2 : i1);
+
+   /* Scale row1 in source */
+   if ((source[row1][1] < SMALL) && (source[row1][1] > -SMALL)) return(FALSE);
+   temp = 1.0 / source[row1][1];
+   source[row1][1]  = 1.0;
+   source[row1][2] *= temp;	/* source[row1][0] is zero already */
+
+   /* Scale row1 in inv */
+   inv[row1][row1]  = temp;	/* it used to be a 1.0 */
+   inv[row1][row0] *= temp;
+
+   /* Clear column one, source, and make corresponding changes in inv */
+
+   for (i = 0; i < 3; i++) if (i != row1) {	/* for i = all rows but row1 */
+   temp = -source[i][1];
+      source[i][1]  = 0.0;
+      source[i][2] += temp * source[row1][2];
+
+      inv[i][row1]  = temp * inv[row1][row1];
+      inv[i][row0] += temp * inv[row1][row0];
+   }
+
+   /* Scale row2 in source */
+   if ((source[row2][2] < SMALL) && (source[row2][2] > -SMALL)) return(FALSE);
+   temp = 1.0 / source[row2][2];
+   source[row2][2] = 1.0;	/* source[row2][*] is zero already */
+
+   /* Scale row2 in inv */
+   inv[row2][row2]  = temp;	/* it used to be a 1.0 */
+   inv[row2][row0] *= temp;
+   inv[row2][row1] *= temp;
+
+   /* Clear column one, source, and make corresponding changes in inv */
+   for (i = 0; i < 3; i++) if (i != row2) {	/* for i = all rows but row2 */
+   temp = -source[i][2];
+      source[i][2] = 0.0;
+      inv[i][row0] += temp * inv[row2][row0];
+      inv[i][row1] += temp * inv[row2][row1];
+      inv[i][row2] += temp * inv[row2][row2];
+   }
+
+   /*
+    * Now all is done except that the inverse needs to have its rows shuffled.
+    * row0 needs to be moved to inv[0][*], row1 to inv[1][*], etc.
+    *
+    * We *didn't* do the swapping before the elimination so that we could more
+    * easily keep track of what ops are needed to be done in the inverse.
+    */
+   MAT3_inv3_swap(inv, row0, row1, row2);
+
+   return(TRUE);
+}
+
+/*
+ * Fast inversion routine for 3 x 3 matrices.	- Written by jfh.
+ *
+ * This takes 30 multiplies/divides, as opposed to 39 for Cramer's Rule.
+ * The algorithm consists of performing fast gaussian elimination, by never
+ * doing any operations where the result is guaranteed to be zero, or where
+ * one operand is guaranteed to be zero. This is done at the cost of clarity,
+ * alas.
+ *
+ * Returns 1 if the inverse was successful, 0 if it failed.
+ */
+
+static int
+MAT3_invert3 (register double source[3][3], register double inv[3][3])
+{
+   register int i, row0;
+   double	temp;
+   double	a, b, c;
+
+   inv[0][0] = inv[1][1] = inv[2][2] = 1.0;
+   inv[0][1] = inv[0][2] = inv[1][0] = inv[1][2] = inv[2][0] = inv[2][1] = 0.0;
+
+   /* attempt to find the largest entry in first column to use as pivot */
+   a = source[0][0]; if (a < 0) a = -a;
+   b = source[1][0]; if (b < 0) b = -b;
+   c = source[2][0]; if (c < 0) c = -c;
+
+   if (a > b) {
+      if (a > c) row0 = 0;
+      else row0 = 2;
+   }
+   else { 
+      if (b > c) row0 = 1;
+      else row0 = 2;
+   }
+
+   /* Scale row0 of source */
+   if ((source[row0][0] < SMALL) && (source[row0][0] > -SMALL)) return(FALSE);
+   temp = 1.0 / source[row0][0];
+   source[row0][0]  = 1.0;
+   source[row0][1] *= temp;
+   source[row0][2] *= temp;
+
+   /* Scale row0 of inverse */
+   inv[row0][row0] = temp;	/* other entries are zero -- no effort	*/
+
+   /* Clear column zero of source, and make corresponding changes in inverse */
+
+   for (i = 0; i < 3; i++) if (i != row0) {	/* for i = all rows but row0 */
+      temp = -source[i][0];
+      source[i][0]  = 0.0;
+      source[i][1] += temp * source[row0][1];
+      source[i][2] += temp * source[row0][2];
+      inv[i][row0]  = temp * inv[row0][row0];
+   }
+
+   /*
+    * We've now done gaussian elimination so that the source and
+    * inverse look like this:
+    *
+    *	1 * *		* 0 0
+    *	0 * *		* 1 0
+    *	0 * *		* 0 1
+    *
+    * We now proceed to do elimination on the second column.
+    */
+   if (! MAT3_inv3_second_col(source, inv, row0)) return(FALSE);
+
+   return(TRUE);
+}
+
+/*
+ * Finds a new pivot for a non-simple 4x4.  See comments in MAT3invert().
+ */
+
+static int
+MAT3_inv4_pivot (register MAT3mat src, MAT3vec r, double *s, int *swap)
+{
+   register int i, j;
+   double	temp, max;
+
+   *swap = -1;
+
+   if (MAT3_IS_ZERO(src[3][3])) {
+
+      /* Look for a different pivot element: one with largest abs value */
+      max = 0.0;
+
+      for (i = 0; i < 4; i++) {
+	 if	 (src[i][3] >  max) max =  src[*swap = i][3];
+	 else if (src[i][3] < -max) max = -src[*swap = i][3];
+      }
+
+      /* No pivot element available ! */
+      if (*swap < 0) return(FALSE);
+
+      else for (j = 0; j < 4; j++) SWAP(src[*swap][j], src[3][j], temp);
+   }
+
+   MAT3_SET_VEC (r, -src[0][3], -src[1][3], -src[2][3]);
+
+   *s = 1.0 / src[3][3];
+
+   src[0][3] = src[1][3] = src[2][3] = 0.0;
+   src[3][3]			     = 1.0;
+
+   MAT3_SCALE_VEC(src[3], src[3], *s);
+
+   for (i = 0; i < 3; i++) {
+      src[0][i] += r[0] * src[3][i];
+      src[1][i] += r[1] * src[3][i];
+      src[2][i] += r[2] * src[3][i];
+   }
+
+   return(TRUE);
+}
+
+/* -------------------------  Internal Routines  --------------------------- */
+
+/* --------------------------  Public Routines	---------------------------- */
+
+/*
+ * This returns the inverse of the given matrix.  The result matrix
+ * may be the same as the one to invert.
+ *
+ * Fast inversion routine for 4 x 4 matrices, written by jfh.
+ *
+ * Returns 1 if the inverse was successful, 0 if it failed.
+ *
+ * This routine has been specially tweaked to notice the following:
+ * If the matrix has the form
+ *	  * * * 0
+ *	  * * * 0
+ *	  * * * 0
+ *	  * * * 1
+ *
+ * (as do many matrices in graphics), then we compute the inverse of
+ * the upper left 3x3 matrix and use this to find the general inverse.
+ *
+ *   In the event that the right column is not 0-0-0-1, we do gaussian
+ * elimination to make it so, then use the 3x3 inverse, and then do
+ * our gaussian elimination.
+ */
+
+int
+MAT3invert(double (*result_mat)[4], double (*mat)[4])
+{
+   MAT3mat		src, inv;
+   register int 	i, j, simple;
+   double		m[3][3], inv3[3][3], s, temp;
+   MAT3vec		r, t;
+   int			swap;
+
+   MAT3copy(src, mat);
+   MAT3identity(inv);
+
+   /* If last column is not (0,0,0,1), use special code */
+   simple = (mat[0][3] == 0.0 && mat[1][3] == 0.0 &&
+	     mat[2][3] == 0.0 && mat[3][3] == 1.0);
+
+   if (! simple && ! MAT3_inv4_pivot(src, r, &s, &swap)) return(FALSE);
+
+   MAT3_COPY_VEC(t, src[3]);	/* Translation vector */
+
+   /* Copy upper-left 3x3 matrix */
+   for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) m[i][j] = src[i][j];
+
+   if (! MAT3_invert3(m, inv3)) return(FALSE);
+
+   for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) inv[i][j] = inv3[i][j];
+
+   for (i = 0; i < 3; i++) for (j = 0; j < 3; j++)
+      inv[3][i] -= t[j] * inv3[j][i];
+
+   if (! simple) {
+
+      /* We still have to undo our gaussian elimination from earlier on */
+      /* add r0 * first col to last col */
+      /* add r1 * 2nd	col to last col */
+      /* add r2 * 3rd	col to last col */
+
+      for (i = 0; i < 4; i++) {
+	 inv[i][3] += r[0] * inv[i][0] + r[1] * inv[i][1] + r[2] * inv[i][2];
+	 inv[i][3] *= s;
+      }
+
+      if (swap >= 0)
+	 for (i = 0; i < 4; i++) SWAP(inv[i][swap], inv[i][3], temp);
+   }
+
+   MAT3copy(result_mat, inv);
+
+   return(TRUE);
+}
@@ -0,0 +1,116 @@
+/* #include "HEADERS.h" */
+/* Copyright 1988, Brown Computer Graphics Group.  All Rights Reserved. */
+
+/* --------------------------------------------------------------------------
+ * This file contains routines that operate solely on matrices.
+ * -------------------------------------------------------------------------*/
+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef WIN32
+#  ifndef HAVE_STL_SGI_PORT
+#    include <memory.h>      /* required for memset() and memcpy() */
+#  endif
+#endif
+
+#include <string.h>
+#include <Math/mat3defs.h>
+
+MAT3mat identityMatrix = {
+    { 1.0, 0.0, 0.0, 0.0 },
+    { 0.0, 1.0, 0.0, 0.0 },
+    { 0.0, 0.0, 1.0, 0.0 },
+    { 0.0, 0.0, 0.0, 1.0 }
+};
+
+/* #include "macros.h" */
+
+/* --------------------------  Static Routines	---------------------------- */
+
+/* -------------------------  Internal Routines  --------------------------- */
+
+/* --------------------------  Public Routines	---------------------------- */
+
+
+#if !defined( USE_XTRA_MAT3_INLINES )
+
+/*
+ * This multiplies two matrices, producing a third, which may the same as
+ * either of the first two.
+ */
+
+void
+MAT3mult (double (*result_mat)[4], register double (*mat1)[4], register double (*mat2)[4])
+{
+   register int i, j;
+   MAT3mat	tmp_mat;
+
+   for (i = 0; i < 4; i++)
+      for (j = 0; j < 4; j++)
+         tmp_mat[i][j] = (mat1[i][0] * mat2[0][j] +
+		       mat1[i][1] * mat2[1][j] +
+		       mat1[i][2] * mat2[2][j] +
+		       mat1[i][3] * mat2[3][j]);
+   MAT3copy (result_mat, tmp_mat);
+}
+#endif // !defined( USE_XTRA_MAT3_INLINES )
+
+/*
+ * This returns the transpose of a matrix.  The result matrix may be
+ * the same as the one to transpose.
+ */
+
+void
+MAT3transpose (double (*result_mat)[4], register double (*mat)[4])
+{
+   register int i, j;
+   MAT3mat	tmp_mat;
+
+   for (i = 0; i < 4; i++) 
+      for (j = 0; j < 4; j++) 
+         tmp_mat[i][j] = mat[j][i];
+
+   MAT3copy (result_mat, tmp_mat);
+}
+
+
+/*
+ * This prints the given matrix to the given file pointer.
+ */
+
+void
+MAT3print(double (*mat)[4], FILE *fp)
+{
+   MAT3print_formatted(mat, fp, CNULL, CNULL, CNULL, CNULL);
+}
+
+/*
+ * This prints the given matrix to the given file pointer.
+ * use the format string to pass to fprintf.  head and tail
+ * are printed at the beginning and end of each line.
+ */
+
+void
+MAT3print_formatted(double (*mat)[4], FILE *fp, char *title, char *head, char *format, char *tail)
+{
+   register int i, j;
+
+   /* This is to allow this to be called easily from a debugger */
+   if (fp == NULL) fp = stderr;
+
+   if (title  == NULL)	title  = "MAT3 matrix:\n";
+   if (head   == NULL)	head   = "  ";
+   if (format == NULL)	format = "%#8.4lf  ";
+   if (tail   == NULL)	tail   = "\n";
+
+   (void) fprintf(fp, title);
+
+   for (i = 0; i < 4; i++) {
+      (void) fprintf(fp, head);
+      for (j = 0; j < 4; j++) (void) fprintf(fp, format, mat[i][j]);
+      (void) fprintf(fp, tail);
+   }
+}
@@ -0,0 +1,154 @@
+/* Copyright 1988, Brown Computer Graphics Group.  All Rights Reserved. */
+
+/* --------------------------------------------------------------------------
+ * This file contains routines that operate on matrices and vectors, or
+ * vectors and vectors.
+ * -------------------------------------------------------------------------*/
+
+/* #include "sphigslocal.h" */
+
+/* --------------------------  Static Routines	---------------------------- */
+
+/* -------------------------  Internal Routines  --------------------------- */
+
+/* --------------------------  Public Routines	---------------------------- */
+
+/*
+ * Multiplies a vector by a matrix, setting the result vector.
+ * It assumes all homogeneous coordinates are 1.
+ * The two vectors involved may be the same.
+ */
+
+#include <Math/mat3.h>
+
+#ifndef TRUE
+#  define TRUE 1
+#endif
+
+#ifndef FALSE
+#  define FALSE 0
+#endif
+
+#if !defined( USE_XTRA_MAT3_INLINES )
+
+void
+MAT3mult_vec(double *result_vec, register double *vec, register double (*mat)[4])
+{
+   MAT3vec		tempvec;
+   register double	*temp = tempvec;
+
+   temp[0] =	vec[0] * mat[0][0] + vec[1] * mat[1][0] +
+		vec[2] * mat[2][0] +	      mat[3][0];
+   temp[1] =	vec[0] * mat[0][1] + vec[1] * mat[1][1] +
+		vec[2] * mat[2][1] +	      mat[3][1];
+   temp[2] =	vec[0] * mat[0][2] + vec[1] * mat[1][2] +
+		vec[2] * mat[2][2] +	      mat[3][2];
+
+   MAT3_COPY_VEC(result_vec, temp);
+}
+#endif // !defined( USE_XTRA_MAT3_INLINES )
+
+/*
+ * Multiplies a vector of size 4 by a matrix, setting the result vector.
+ * The fourth element of the vector is the homogeneous coordinate, which
+ * may or may not be 1.  If the "normalize" parameter is TRUE, then the
+ * result vector will be normalized so that the homogeneous coordinate is 1.
+ * The two vectors involved may be the same.
+ * This returns zero if the vector was to be normalized, but couldn't be.
+ */
+
+int
+MAT3mult_hvec(double *result_vec, register double *vec, register double (*mat)[4], int normalize)
+{
+   MAT3hvec             tempvec;
+   double		norm_fac;
+   register double	*temp = tempvec;
+   register int 	ret = TRUE;
+
+   temp[0] =	vec[0] * mat[0][0] + vec[1] * mat[1][0] +
+		vec[2] * mat[2][0] + vec[3] * mat[3][0];
+   temp[1] =	vec[0] * mat[0][1] + vec[1] * mat[1][1] +
+		vec[2] * mat[2][1] + vec[3] * mat[3][1];
+   temp[2] =	vec[0] * mat[0][2] + vec[1] * mat[1][2] +
+		vec[2] * mat[2][2] + vec[3] * mat[3][2];
+   temp[3] =	vec[0] * mat[0][3] + vec[1] * mat[1][3] +
+		vec[2] * mat[2][3] + vec[3] * mat[3][3];
+
+   /* Normalize if asked for, possible, and necessary */
+   if (normalize) {
+      if (MAT3_IS_ZERO(temp[3])) {
+#ifndef THINK_C
+	 fprintf (stderr,
+		  "Can't normalize vector: homogeneous coordinate is 0");
+#endif
+	 ret = FALSE;
+      }
+      else {
+	 norm_fac = 1.0 / temp[3];
+	 MAT3_SCALE_VEC(result_vec, temp, norm_fac);
+	 result_vec[3] = 1.0;
+      }
+   }
+   else MAT3_COPY_HVEC(result_vec, temp);
+
+   return(ret);
+}
+
+#if !defined( USE_XTRA_MAT3_INLINES )
+
+/*
+ * Sets the first vector to be the cross-product of the last two vectors.
+ */
+
+void
+MAT3cross_product(double *result_vec, register double *vec1, register double *vec2)
+{
+   MAT3vec		tempvec;
+   register double	*temp = tempvec;
+
+   temp[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
+   temp[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
+   temp[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
+
+   MAT3_COPY_VEC(result_vec, temp);
+}
+#endif // !defined( USE_XTRA_MAT3_INLINES )
+
+/*
+ * Finds a vector perpendicular to vec and stores it in result_vec.
+ * Method:  take any vector (we use <0,1,0>) and subtract the
+ * portion of it pointing in the vec direction.  This doesn't
+ * work if vec IS <0,1,0> or is very near it.  So if this is
+ * the case, use <0,0,1> instead.
+ * If "is_unit" is TRUE, the given vector is assumed to be unit length.
+ */
+
+#define SELECT	.7071	/* selection constant (roughly .5*sqrt(2) */
+
+void
+MAT3perp_vec(double *result_vec, double *vec, int is_unit)
+{
+   MAT3vec	norm;
+   double	dot;
+
+   MAT3_SET_VEC(result_vec, 0.0, 1.0, 0.0);
+
+   MAT3_COPY_VEC(norm, vec);
+
+   if (! is_unit) MAT3_NORMALIZE_VEC(norm, dot);
+
+   /* See if vector is too close to <0,1,0>.  If so, use <0,0,1> */
+   if ((dot = MAT3_DOT_PRODUCT(norm, result_vec)) > SELECT || dot < -SELECT) {
+      result_vec[1] = 0.0;
+      result_vec[2] = 1.0;
+      dot = MAT3_DOT_PRODUCT(norm, result_vec);
+   }
+
+   /* Subtract off non-perpendicular part */
+   result_vec[0] -= dot * norm[0];
+   result_vec[1] -= dot * norm[1];
+   result_vec[2] -= dot * norm[2];
+
+   /* Make result unit length */
+   MAT3_NORMALIZE_VEC(result_vec, dot);
+}
@@ -0,0 +1,17 @@
+noinst_LIBRARIES = libMath.a
+
+libMath_a_SOURCES = \
+	MAT3geom.c \
+	MAT3inv.c \
+	MAT3mat.c \
+	MAT3vec.c \
+	fg_geodesy.cxx fg_geodesy.hxx \
+	fg_random.c fg_random.h \
+	interpolater.cxx interpolater.hxx \
+	leastsqs.cxx leastsqs.hxx \
+	mat3.h mat3defs.h mat3err.h \
+	point3d.hxx \
+	polar3d.cxx polar3d.hxx \
+	vector.cxx vector.hxx
+
+INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib -I$(top_builddir)/Simulator
@@ -0,0 +1,301 @@
+// fg_geodesy.cxx -- routines to convert between geodetic and geocentric 
+//                   coordinate systems.
+//
+// Copied and adapted directly from LaRCsim/ls_geodesy.c
+//
+// See below for the complete original LaRCsim comments.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#include "Include/compiler.h"
+#ifdef FG_HAVE_STD_INCLUDES
+# include <cmath>
+# include <cerrno>
+#else
+# include <math.h>
+# include <errno.h>
+#endif
+
+#include <Include/fg_constants.h>
+#include <Math/fg_geodesy.hxx>
+#include <Math/point3d.hxx>
+
+#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
+FG_USING_STD(cout);
+#endif
+
+// ONE_SECOND is pi/180/60/60, or about 100 feet at earths' equator
+#define ONE_SECOND 4.848136811E-6
+
+
+// fgGeocToGeod(lat_geoc, radius, *lat_geod, *alt, *sea_level_r)
+//     INPUTS:	
+//         lat_geoc	Geocentric latitude, radians, + = North
+//         radius	C.G. radius to earth center (meters)
+//
+//     OUTPUTS:
+//         lat_geod	Geodetic latitude, radians, + = North
+//         alt		C.G. altitude above mean sea level (meters)
+//         sea_level_r	radius from earth center to sea level at
+//                      local vertical (surface normal) of C.G. (meters)
+
+
+void fgGeocToGeod( double lat_geoc, double radius, double
+		   *lat_geod, double *alt, double *sea_level_r )
+{
+    double t_lat, x_alpha, mu_alpha, delt_mu, r_alpha, l_point, rho_alpha;
+    double sin_mu_a, denom,delt_lambda, lambda_sl, sin_lambda_sl;
+
+    if( ( (FG_PI_2 - lat_geoc) < ONE_SECOND )        // near North pole
+	|| ( (FG_PI_2 + lat_geoc) < ONE_SECOND ) )   // near South pole
+    {
+	*lat_geod = lat_geoc;
+	*sea_level_r = EQUATORIAL_RADIUS_M*E;
+	*alt = radius - *sea_level_r;
+    } else {
+	t_lat = tan(lat_geoc);
+	x_alpha = E*EQUATORIAL_RADIUS_M/sqrt(t_lat*t_lat + E*E);
+	double tmp = RESQ_M - x_alpha * x_alpha;
+	if ( tmp < 0.0 ) { tmp = 0.0; }
+	mu_alpha = atan2(sqrt(tmp),E*x_alpha);
+	if (lat_geoc < 0) mu_alpha = - mu_alpha;
+	sin_mu_a = sin(mu_alpha);
+	delt_lambda = mu_alpha - lat_geoc;
+	r_alpha = x_alpha/cos(lat_geoc);
+	l_point = radius - r_alpha;
+	*alt = l_point*cos(delt_lambda);
+
+	// check for domain error
+	if ( errno == EDOM ) {
+	    cout << "Domain ERROR in fgGeocToGeod!!!!\n";
+	    *alt = 0.0;
+	}
+
+	denom = sqrt(1-EPS*EPS*sin_mu_a*sin_mu_a);
+	rho_alpha = EQUATORIAL_RADIUS_M*(1-EPS)/
+	    (denom*denom*denom);
+	delt_mu = atan2(l_point*sin(delt_lambda),rho_alpha + *alt);
+	*lat_geod = mu_alpha - delt_mu;
+	lambda_sl = atan( E*E * tan(*lat_geod) ); // SL geoc. latitude
+	sin_lambda_sl = sin( lambda_sl );
+	*sea_level_r = 
+	    sqrt(RESQ_M / (1 + ((1/(E*E))-1)*sin_lambda_sl*sin_lambda_sl));
+
+	// check for domain error
+	if ( errno == EDOM ) {
+	    cout << "Domain ERROR in fgGeocToGeod!!!!\n";
+	    *sea_level_r = 0.0;
+	}
+    }
+
+}
+
+
+// fgGeodToGeoc( lat_geod, alt, *sl_radius, *lat_geoc )
+//     INPUTS:	
+//         lat_geod	Geodetic latitude, radians, + = North
+//         alt		C.G. altitude above mean sea level (meters)
+//
+//     OUTPUTS:
+//         sl_radius	SEA LEVEL radius to earth center (meters)
+//                      (add Altitude to get true distance from earth center.
+//         lat_geoc	Geocentric latitude, radians, + = North
+//
+
+
+void fgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
+		      double *lat_geoc )
+{
+    double lambda_sl, sin_lambda_sl, cos_lambda_sl, sin_mu, cos_mu, px, py;
+    
+    lambda_sl = atan( E*E * tan(lat_geod) ); // sea level geocentric latitude
+    sin_lambda_sl = sin( lambda_sl );
+    cos_lambda_sl = cos( lambda_sl );
+    sin_mu = sin(lat_geod);                  // Geodetic (map makers') latitude
+    cos_mu = cos(lat_geod);
+    *sl_radius = 
+	sqrt(RESQ_M / (1 + ((1/(E*E))-1)*sin_lambda_sl*sin_lambda_sl));
+    py = *sl_radius*sin_lambda_sl + alt*sin_mu;
+    px = *sl_radius*cos_lambda_sl + alt*cos_mu;
+    *lat_geoc = atan2( py, px );
+}
+
+
+/***************************************************************************
+
+	TITLE:	ls_geodesy
+	
+----------------------------------------------------------------------------
+
+	FUNCTION:	Converts geocentric coordinates to geodetic positions
+
+----------------------------------------------------------------------------
+
+	MODULE STATUS:	developmental
+
+----------------------------------------------------------------------------
+
+	GENEALOGY:	Written as part of LaRCSim project by E. B. Jackson
+
+----------------------------------------------------------------------------
+
+	DESIGNED BY:	E. B. Jackson
+	
+	CODED BY:	E. B. Jackson
+	
+	MAINTAINED BY:	E. B. Jackson
+
+----------------------------------------------------------------------------
+
+	MODIFICATION HISTORY:
+	
+	DATE	PURPOSE						BY
+	
+	930208	Modified to avoid singularity near polar region.	EBJ
+	930602	Moved backwards calcs here from ls_step.		EBJ
+	931214	Changed erroneous Latitude and Altitude variables to 
+		*lat_geod and *alt in routine ls_geoc_to_geod.		EBJ
+	940111	Changed header files from old ls_eom.h style to ls_types, 
+		and ls_constants.  Also replaced old DATA type with new
+		SCALAR type.						EBJ
+
+	CURRENT RCS HEADER:
+
+$Header$
+$Log$
+Revision 1.6  1999/03/02 01:01:49  curt
+Tweaks for compiling with native SGI compilers.
+
+Revision 1.5  1999/01/27 04:46:14  curt
+Portability tweaks by Bernie Bright.
+
+Revision 1.4  1998/11/20 01:00:36  curt
+Patch in fgGeoc2Geod() to avoid a floating explosion.
+point3d.hxx include math.h for FreeBSD
+
+Revision 1.3  1998/11/11 00:18:36  curt
+Check for domain error in fgGeoctoGeod()
+
+Revision 1.2  1998/10/16 23:36:36  curt
+c++-ifying.
+
+Revision 1.1  1998/10/16 19:30:40  curt
+Renamed .c -> .h so we can start adding c++ supporting routines.
+
+Revision 1.6  1998/07/08 14:40:07  curt
+polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+Updated fg_geodesy comments to reflect that routines expect and produce
+  meters.
+
+Revision 1.5  1998/04/25 22:06:23  curt
+Edited cvs log messages in source files ... bad bad bad!
+
+Revision 1.4  1998/01/27 00:47:59  curt
+Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
+system and commandline/config file processing code.
+
+Revision 1.3  1998/01/19 19:27:12  curt
+Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+This should simplify things tremendously.
+
+Revision 1.2  1997/12/15 23:54:54  curt
+Add xgl wrappers for debugging.
+Generate terrain normals on the fly.
+
+Revision 1.1  1997/07/31 23:13:14  curt
+Initial revision.
+
+Revision 1.1  1997/05/29 00:09:56  curt
+Initial Flight Gear revision.
+
+ * Revision 1.5  1994/01/11  18:47:05  bjax
+ * Changed include files to use types and constants, not ls_eom.h
+ * Also changed DATA type to SCALAR type.
+ *
+ * Revision 1.4  1993/12/14  21:06:47  bjax
+ * Removed global variable references Altitude and Latitude.   EBJ
+ *
+ * Revision 1.3  1993/06/02  15:03:40  bjax
+ * Made new subroutine for calculating geodetic to geocentric; changed name
+ * of forward conversion routine from ls_geodesy to ls_geoc_to_geod.
+ *
+
+----------------------------------------------------------------------------
+
+	REFERENCES:
+
+		[ 1]	Stevens, Brian L.; and Lewis, Frank L.: "Aircraft 
+			Control and Simulation", Wiley and Sons, 1992.
+			ISBN 0-471-61397-5		      
+
+
+----------------------------------------------------------------------------
+
+	CALLED BY:	ls_aux
+
+----------------------------------------------------------------------------
+
+	CALLS TO:
+
+----------------------------------------------------------------------------
+
+	INPUTS:	
+		lat_geoc	Geocentric latitude, radians, + = North
+		radius		C.G. radius to earth center, ft
+
+----------------------------------------------------------------------------
+
+	OUTPUTS:
+		lat_geod	Geodetic latitude, radians, + = North
+		alt		C.G. altitude above mean sea level, ft
+		sea_level_r	radius from earth center to sea level at
+				local vertical (surface normal) of C.G.
+
+--------------------------------------------------------------------------*/
+
+
+// $Log$
+// Revision 1.6  1999/03/02 01:01:49  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.5  1999/01/27 04:46:14  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.4  1998/11/20 01:00:36  curt
+// Patch in fgGeoc2Geod() to avoid a floating explosion.
+// point3d.hxx include math.h for FreeBSD
+//
+// Revision 1.3  1998/11/11 00:18:36  curt
+// Check for domain error in fgGeoctoGeod()
+//
+// Revision 1.2  1998/10/16 23:36:36  curt
+// c++-ifying.
+//
+// Revision 1.1  1998/10/16 19:30:40  curt
+// Renamed .c -> .h so we can start adding c++ supporting routines.
+//
+// Revision 1.6  1998/07/08 14:40:07  curt
+// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+// Updated fg_geodesy comments to reflect that routines expect and produce
+//   meters.
+//
+// Revision 1.5  1998/04/25 22:06:23  curt
+// Edited cvs log messages in source files ... bad bad bad!
+//
+// Revision 1.4  1998/01/27 00:47:59  curt
+// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
+// system and commandline/config file processing code.
+//
+// Revision 1.3  1998/01/19 19:27:12  curt
+// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+// This should simplify things tremendously.
+//
+// Revision 1.2  1997/12/15 23:54:54  curt
+// Add xgl wrappers for debugging.
+// Generate terrain normals on the fly.
+//
+// Revision 1.1  1997/07/31 23:13:14  curt
+// Initial revision.
+//
+
@@ -0,0 +1,222 @@
+// fg_geodesy.hxx -- routines to convert between geodetic and geocentric 
+//                   coordinate systems.
+//
+// Copied and adapted directly from LaRCsim/ls_geodesy.c
+//
+// See below for the complete original LaRCsim comments.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _FG_GEODESY_HXX
+#define _FG_GEODESY_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+
+#include <Math/point3d.hxx>
+#include <Math/polar3d.hxx>
+
+
+// fgGeocToGeod(lat_geoc, radius, *lat_geod, *alt, *sea_level_r)
+//     INPUTS:	
+//         lat_geoc	Geocentric latitude, radians, + = North
+//         radius	C.G. radius to earth center (meters)
+//
+//     OUTPUTS:
+//         lat_geod	Geodetic latitude, radians, + = North
+//         alt		C.G. altitude above mean sea level (meters)
+//         sea_level_r	radius from earth center to sea level at
+//                      local vertical (surface normal) of C.G. (meters)
+
+void fgGeocToGeod( double lat_geoc, double radius, double
+		   *lat_geod, double *alt, double *sea_level_r );
+
+
+// fgGeodToGeoc( lat_geod, alt, *sl_radius, *lat_geoc )
+//     INPUTS:	
+//         lat_geod	Geodetic latitude, radians, + = North
+//         alt		C.G. altitude above mean sea level (meters)
+//
+//     OUTPUTS:
+//         sl_radius	SEA LEVEL radius to earth center (meters)
+//                      (add Altitude to get true distance from earth center.
+//         lat_geoc	Geocentric latitude, radians, + = North
+//
+
+void fgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
+		      double *lat_geoc );
+
+
+// convert a geodetic point lon(radians), lat(radians), elev(meter) to
+// a cartesian point
+
+inline Point3D fgGeodToCart(const Point3D& geod) {
+    double gc_lon, gc_lat, sl_radius;
+
+    // printf("A geodetic point is (%.2f, %.2f, %.2f)\n", 
+    //        geod[0], geod[1], geod[2]);
+
+    gc_lon = geod.lon();
+    fgGeodToGeoc(geod.lat(), geod.radius(), &sl_radius, &gc_lat);
+
+    // printf("A geocentric point is (%.2f, %.2f, %.2f)\n", gc_lon, 
+    //        gc_lat, sl_radius+geod[2]);
+
+    Point3D pp = Point3D( gc_lon, gc_lat, sl_radius + geod.radius());
+    return fgPolarToCart3d(pp);
+}
+
+
+/***************************************************************************
+
+	TITLE:	ls_geodesy
+	
+----------------------------------------------------------------------------
+
+	FUNCTION:	Converts geocentric coordinates to geodetic positions
+
+----------------------------------------------------------------------------
+
+	MODULE STATUS:	developmental
+
+----------------------------------------------------------------------------
+
+	GENEALOGY:	Written as part of LaRCSim project by E. B. Jackson
+
+----------------------------------------------------------------------------
+
+	DESIGNED BY:	E. B. Jackson
+	
+	CODED BY:	E. B. Jackson
+	
+	MAINTAINED BY:	E. B. Jackson
+
+----------------------------------------------------------------------------
+
+	MODIFICATION HISTORY:
+	
+	DATE	PURPOSE						BY
+	
+	930208	Modified to avoid singularity near polar region.	EBJ
+	930602	Moved backwards calcs here from ls_step.		EBJ
+	931214	Changed erroneous Latitude and Altitude variables to 
+		*lat_geod and *alt in routine ls_geoc_to_geod.		EBJ
+	940111	Changed header files from old ls_eom.h style to ls_types, 
+		and ls_constants.  Also replaced old DATA type with new
+		SCALAR type.						EBJ
+
+	CURRENT RCS HEADER:
+
+$Header$
+$Log$
+Revision 1.4  1999/01/27 04:46:15  curt
+Portability tweaks by Bernie Bright.
+
+Revision 1.3  1998/10/18 01:17:11  curt
+Point3D tweaks.
+
+Revision 1.2  1998/10/16 23:36:37  curt
+c++-ifying.
+
+Revision 1.1  1998/10/16 19:30:42  curt
+Renamed .c -> .h so we can start adding c++ supporting routines.
+
+Revision 1.4  1998/07/08 14:40:08  curt
+polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+Updated fg_geodesy comments to reflect that routines expect and produce
+  meters.
+
+Revision 1.3  1998/04/21 17:03:48  curt
+Prepairing for C++ integration.
+
+Revision 1.2  1998/01/22 02:59:38  curt
+Changed #ifdef FILE_H to #ifdef _FILE_H
+
+Revision 1.1  1997/07/31 23:13:14  curt
+Initial revision.
+
+Revision 1.1  1997/05/29 00:09:56  curt
+Initial Flight Gear revision.
+
+ * Revision 1.5  1994/01/11  18:47:05  bjax
+ * Changed include files to use types and constants, not ls_eom.h
+ * Also changed DATA type to SCALAR type.
+ *
+ * Revision 1.4  1993/12/14  21:06:47  bjax
+ * Removed global variable references Altitude and Latitude.   EBJ
+ *
+ * Revision 1.3  1993/06/02  15:03:40  bjax
+ * Made new subroutine for calculating geodetic to geocentric; changed name
+ * of forward conversion routine from ls_geodesy to ls_geoc_to_geod.
+ *
+
+----------------------------------------------------------------------------
+
+	REFERENCES:
+
+		[ 1]	Stevens, Brian L.; and Lewis, Frank L.: "Aircraft 
+			Control and Simulation", Wiley and Sons, 1992.
+			ISBN 0-471-61397-5		      
+
+
+----------------------------------------------------------------------------
+
+	CALLED BY:	ls_aux
+
+----------------------------------------------------------------------------
+
+	CALLS TO:
+
+----------------------------------------------------------------------------
+
+	INPUTS:	
+		lat_geoc	Geocentric latitude, radians, + = North
+		radius		C.G. radius to earth center, ft
+
+----------------------------------------------------------------------------
+
+	OUTPUTS:
+		lat_geod	Geodetic latitude, radians, + = North
+		alt		C.G. altitude above mean sea level, ft
+		sea_level_r	radius from earth center to sea level at
+				local vertical (surface normal) of C.G.
+
+--------------------------------------------------------------------------*/
+
+
+#endif // _FG_GEODESY_HXX
+
+
+// $Log$
+// Revision 1.4  1999/01/27 04:46:15  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.3  1998/10/18 01:17:11  curt
+// Point3D tweaks.
+//
+// Revision 1.2  1998/10/16 23:36:37  curt
+// c++-ifying.
+//
+// Revision 1.1  1998/10/16 19:30:42  curt
+// Renamed .c -> .h so we can start adding c++ supporting routines.
+//
+// Revision 1.4  1998/07/08 14:40:08  curt
+// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+// Updated fg_geodesy comments to reflect that routines expect and produce
+//   meters.
+//
+// Revision 1.3  1998/04/21 17:03:48  curt
+// Prepairing for C++ integration.
+//
+// Revision 1.2  1998/01/22 02:59:38  curt
+// Changed #ifdef FILE_H to #ifdef _FILE_H
+//
+// Revision 1.1  1997/07/31 23:13:14  curt
+// Initial revision.
+//
+
@@ -0,0 +1,114 @@
+// fg_random.c -- routines to handle random number generation
+//
+// Written by Curtis Olson, started July 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>         // for random(), srandom()
+#include <time.h>           // for time() to seed srandom()        
+
+#include "fg_random.h"
+
+#ifndef HAVE_RAND
+#  ifdef sgi
+#    undef RAND_MAX
+#    define RAND_MAX 2147483647
+#  endif
+#endif
+
+#ifdef __SUNPRO_CC
+    extern "C" {
+	long int random(void);
+	void srandom(unsigned int seed);
+    }
+#endif
+
+
+// Seed the random number generater with time() so we don't see the
+// same sequence every time
+void fg_srandom(void) {
+    // fgPrintf( FG_MATH, FG_INFO, "Seeding random number generater\n");
+
+#ifdef HAVE_RAND
+    srand(time(NULL));
+#else
+    srandom(time(NULL));
+#endif                                       
+}
+
+
+// return a random number between [0.0, 1.0)
+double fg_random(void) {
+#ifdef HAVE_RAND
+    return(rand() / (double)RAND_MAX);
+#else
+    return(random() / (double)RAND_MAX);
+#endif
+}
+
+
+// $Log$
+// Revision 1.10  1998/11/07 19:07:03  curt
+// Enable release builds using the --without-logging option to the configure
+// script.  Also a couple log message cleanups, plus some C to C++ comment
+// conversion.
+//
+// Revision 1.9  1998/11/06 21:17:26  curt
+// Converted to new logstream debugging facility.  This allows release
+// builds with no messages at all (and no performance impact) by using
+// the -DFG_NDEBUG flag.
+//
+// Revision 1.8  1998/04/25 22:06:23  curt
+// Edited cvs log messages in source files ... bad bad bad!
+//
+// Revision 1.7  1998/04/24 00:43:13  curt
+// Wrapped "#include <config.h>" in "#ifdef HAVE_CONFIG_H"
+//
+// Revision 1.6  1998/04/18 03:53:42  curt
+// Miscellaneous Tweaks.
+//
+// Revision 1.5  1998/04/03 22:10:29  curt
+// Converting to Gnu autoconf system.
+//
+// Revision 1.4  1998/02/03 23:20:28  curt
+// Lots of little tweaks to fix various consistency problems discovered by
+// Solaris' CC.  Fixed a bug in fg_debug.c with how the fgPrintf() wrapper
+// passed arguments along to the real printf().  Also incorporated HUD changes
+// by Michele America.
+//
+// Revision 1.3  1998/01/27 00:47:59  curt
+// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
+// system and commandline/config file processing code.
+//
+// Revision 1.2  1997/12/30 20:47:48  curt
+// Integrated new event manager with subsystem initializations.
+//
+// Revision 1.1  1997/07/30 16:04:09  curt
+// Moved random routines from Utils/ to Math/
+//
+// Revision 1.1  1997/07/19 22:31:57  curt
+// Initial revision.
+//
@@ -0,0 +1,70 @@
+// fg_random.h -- routines to handle random number generation
+//
+// Written by Curtis Olson, started July 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _FG_RANDOM_H
+#define _FG_RANDOM_H
+
+
+#ifdef __cplusplus                                                          
+extern "C" {                            
+#endif                                   
+
+
+// Seed the random number generater with time() so we don't see the
+// same sequence every time
+void fg_srandom(void);
+
+// return a random number between [0.0, 1.0)
+double fg_random(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // _FG_RANDOM_H
+
+
+// $Log$
+// Revision 1.4  1998/11/07 19:07:04  curt
+// Enable release builds using the --without-logging option to the configure
+// script.  Also a couple log message cleanups, plus some C to C++ comment
+// conversion.
+//
+// Revision 1.3  1998/04/21 17:03:48  curt
+// Prepairing for C++ integration.
+//
+// Revision 1.2  1998/01/22 02:59:38  curt
+// Changed #ifdef FILE_H to #ifdef _FILE_H
+//
+// Revision 1.1  1997/07/30 16:04:09  curt
+// Moved random routines from Utils/ to Math/
+//
+// Revision 1.2  1997/07/23 21:52:28  curt
+// Put comments around the text after an #endif for increased portability.
+//
+// Revision 1.1  1997/07/19 22:31:57  curt
+// Initial revision.
+//
@@ -0,0 +1,131 @@
+//
+// interpolater.cxx -- routines to handle linear interpolation from a table of
+//                     x,y   The table must be sorted by "x" in ascending order
+//
+// Written by Curtis Olson, started April 1998.
+//
+// Copyright (C) 1998  Curtis L. Olson  - curt@me.umn.edu
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#include <Include/compiler.h>
+
+#include STL_STRING
+
+#include <Debug/logstream.hxx>
+#include <Include/fg_zlib.h>
+#include <Misc/fgstream.hxx>
+
+#include "interpolater.hxx"
+
+
+// Constructor -- loads the interpolation table from the specified
+// file
+fgINTERPTABLE::fgINTERPTABLE( const string& file ) {
+    FG_LOG( FG_MATH, FG_INFO, "Initializing Interpolator for " << file );
+
+    fg_gzifstream in( file );
+    if ( !in ) {
+        FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << file );
+	exit(-1);
+    }
+
+    size = 0;
+    in >> skipcomment;
+    while ( ! in.eof() ){
+	if ( size < MAX_TABLE_SIZE ) {
+	    in >> table[size][0] >> table[size][1];
+	    size++;
+	} else {
+            FG_LOG( FG_MATH, FG_ALERT,
+		    "fgInterpolateInit(): Exceed max table size = "
+		    << MAX_TABLE_SIZE );
+	    exit(-1);
+	}
+    }
+}
+
+
+// Given an x value, linearly interpolate the y value from the table
+double fgINTERPTABLE::interpolate(double x) {
+    int i;
+    double y;
+
+    i = 0;
+
+    while ( (x > table[i][0]) && (i < size) ) {
+	i++;
+    }
+
+    // printf ("i = %d ", i);
+
+    if ( (i == 0) && (x < table[0][0]) ) {
+	FG_LOG( FG_MATH, FG_ALERT, 
+		"fgInterpolateInit(): lookup error, x to small = " << x );
+	return(0.0);
+    }
+
+    if ( x > table[i][0] ) {
+	FG_LOG( FG_MATH, FG_ALERT, 
+		"fgInterpolateInit(): lookup error, x to big = " << x );
+	return(0.0);
+    }
+
+    // y = y1 + (y0 - y1)(x - x1) / (x0 - x1)
+    y = table[i][1] + 
+	( (table[i-1][1] - table[i][1]) * 
+	  (x - table[i][0]) ) /
+	(table[i-1][0] - table[i][0]);
+
+    return(y);
+}
+
+
+// Destructor
+fgINTERPTABLE::~fgINTERPTABLE( void ) {
+}
+
+
+// $Log$
+// Revision 1.7  1999/02/26 22:08:03  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.6  1999/01/27 04:46:16  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.5  1998/11/06 21:17:27  curt
+// Converted to new logstream debugging facility.  This allows release
+// builds with no messages at all (and no performance impact) by using
+// the -DFG_NDEBUG flag.
+//
+// Revision 1.4  1998/05/13 18:24:25  curt
+// Wrapped zlib calls so zlib can be optionally disabled.
+//
+// Revision 1.3  1998/04/25 15:05:01  curt
+// Changed "r" to "rb" in gzopen() options.  This fixes bad behavior in win32.
+//
+// Revision 1.2  1998/04/22 13:18:10  curt
+// C++ - ified comments.  Make file open errors fatal.
+//
+// Revision 1.1  1998/04/21 19:14:23  curt
+// Modified Files:
+//     Makefile.am Makefile.in
+// Added Files:
+//     interpolater.cxx interpolater.hxx
+//
@@ -0,0 +1,87 @@
+//
+// interpolater.hxx -- routines to handle linear interpolation from a table of
+//                     x,y   The table must be sorted by "x" in ascending order
+//
+// Written by Curtis Olson, started April 1998.
+//
+// Copyright (C) 1998  Curtis L. Olson  - curt@me.umn.edu
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _INTERPOLATER_H
+#define _INTERPOLATER_H
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include "Include/compiler.h"
+
+#include STL_STRING
+FG_USING_STD(string);
+
+#define MAX_TABLE_SIZE 32
+
+
+class fgINTERPTABLE {
+    int size;
+    double table[MAX_TABLE_SIZE][2];
+
+public:
+
+    // Constructor -- loads the interpolation table from the specified
+    // file
+    fgINTERPTABLE( const string& file );
+
+    // Given an x value, linearly interpolate the y value from the table
+    double interpolate(double x);
+
+    // Destructor
+    ~fgINTERPTABLE( void );
+};
+
+
+#endif // _INTERPOLATER_H
+
+
+// $Log$
+// Revision 1.6  1999/03/02 01:01:50  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.5  1999/02/26 22:08:05  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.4  1999/01/27 04:46:17  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.3  1998/11/06 21:17:28  curt
+// Converted to new logstream debugging facility.  This allows release
+// builds with no messages at all (and no performance impact) by using
+// the -DFG_NDEBUG flag.
+//
+// Revision 1.2  1998/04/22 13:18:10  curt
+// C++ - ified comments.  Make file open errors fatal.
+//
+// Revision 1.1  1998/04/21 19:14:23  curt
+// Modified Files:
+//     Makefile.am Makefile.in
+// Added Files:
+//     interpolater.cxx interpolater.hxx
+//
@@ -0,0 +1,152 @@
+// leastsqs.c -- Implements a simple linear least squares best fit routine
+//
+// Written by Curtis Olson, started September 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+//
+
+
+#include <stdio.h>
+
+#include "leastsqs.hxx"
+
+
+/* 
+Least squares fit:
+
+y = b0 + b1x
+
+     n*sum(xi*yi) - (sum(xi)*sum(yi))
+b1 = --------------------------------
+     n*sum(xi^2) - (sum(xi))^2
+
+
+b0 = sum(yi)/n - b1*(sum(xi)/n)
+*/
+
+double sum_xi, sum_yi, sum_xi_2, sum_xi_yi;
+int sum_n;
+
+void least_squares(double *x, double *y, int n, double *m, double *b) {
+    int i;
+
+    sum_xi = sum_yi = sum_xi_2 = sum_xi_yi = 0.0;
+    sum_n = n;
+
+    for ( i = 0; i < n; i++ ) {
+	sum_xi += x[i];
+	sum_yi += y[i];
+	sum_xi_2 += x[i] * x[i];
+	sum_xi_yi += x[i] * y[i];
+    }
+
+    /* printf("sum(xi)=%.2f  sum(yi)=%.2f  sum(xi^2)=%.2f  sum(xi*yi)=%.2f\n",
+	   sum_xi, sum_yi, sum_xi_2, sum_xi_yi); */
+
+    *m = ( (double)sum_n * sum_xi_yi - sum_xi * sum_yi ) / 
+	( (double)sum_n * sum_xi_2 - sum_xi * sum_xi );
+    *b = (sum_yi / (double)sum_n) - (*m) * (sum_xi / (double)sum_n);
+
+    /* printf("slope = %.2f  intercept = %.2f\n", *m, *b); */
+}
+
+
+/* incrimentally update existing values with a new data point */
+void least_squares_update(double x, double y, double *m, double *b) {
+    ++sum_n;
+
+    sum_xi += x;
+    sum_yi += y;
+    sum_xi_2 += x * x;
+    sum_xi_yi += x * y;
+
+    /* printf("sum(xi)=%.2f  sum(yi)=%.2f  sum(xi^2)=%.2f  sum(xi*yi)=%.2f\n",
+	   sum_xi, sum_yi, sum_xi_2, sum_xi_yi); */
+
+    *m = ( (double)sum_n * sum_xi_yi - sum_xi * sum_yi ) / 
+	( (double)sum_n * sum_xi_2 - sum_xi * sum_xi );
+    *b = (sum_yi / (double)sum_n) - (*m) * (sum_xi / (double)sum_n);
+
+    /* printf("slope = %.2f  intercept = %.2f\n", *m, *b); */
+}
+
+
+/* 
+  return the least squares error:
+
+              (y[i] - y_hat[i])^2
+              -------------------
+                      n
+ */
+double least_squares_error(double *x, double *y, int n, double m, double b) {
+    int i;
+    double error, sum;
+
+    sum = 0.0;
+
+    for ( i = 0; i < n; i++ ) {
+	error = y[i] - (m * x[i] + b);
+	sum += error * error;
+	// printf("%.2f %.2f\n", error, sum);
+    }
+
+    return ( sum / (double)n );
+}
+
+
+/* 
+  return the maximum least squares error:
+
+              (y[i] - y_hat[i])^2
+ */
+double least_squares_max_error(double *x, double *y, int n, double m, double b){
+    int i;
+    double error, max_error;
+
+    max_error = 0.0;
+
+    for ( i = 0; i < n; i++ ) {
+	error = y[i] - (m * x[i] + b);
+	error = error * error;
+	if ( error > max_error ) {
+	    max_error = error;
+	}
+    }
+
+    return ( max_error );
+}
+
+
+// $Log$
+// Revision 1.1  1999/03/13 17:34:45  curt
+// Moved to math subdirectory.
+//
+// Revision 1.2  1998/04/21 17:03:41  curt
+// Prepairing for C++ integration.
+//
+// Revision 1.1  1998/04/08 22:57:24  curt
+// Adopted Gnu automake/autoconf system.
+//
+// Revision 1.1  1998/03/19 02:54:47  curt
+// Reorganized into a class lib called fgDEM.
+//
+// Revision 1.1  1997/10/13 17:02:35  curt
+// Initial revision.
+//
@@ -0,0 +1,90 @@
+// leastsqs.h -- Implements a simple linear least squares best fit routine
+//
+// Written by Curtis Olson, started September 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+///
+
+
+#ifndef _LEASTSQS_H
+#define _LEASTSQS_H
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+
+/* 
+Least squares fit:
+
+y = b0 + b1x
+
+     n*sum(xi*yi) - (sum(xi)*sum(yi))
+b1 = --------------------------------
+     n*sum(xi^2) - (sum(xi))^2
+
+
+b0 = sum(yi)/n - b1*(sum(xi)/n)
+*/
+
+void least_squares(double *x, double *y, int n, double *m, double *b);
+
+/* incrimentally update existing values with a new data point */
+void least_squares_update(double x, double y, double *m, double *b);
+
+
+/* 
+  return the least squares error:
+
+              (y[i] - y_hat[i])^2
+              -------------------
+                      n
+*/
+double least_squares_error(double *x, double *y, int n, double m, double b);
+
+
+/* 
+  return the maximum least squares error:
+
+              (y[i] - y_hat[i])^2
+*/
+double least_squares_max_error(double *x, double *y, int n, double m, double b);
+
+
+#endif // _LEASTSQS_H
+
+
+// $Log$
+// Revision 1.1  1999/03/13 17:34:45  curt
+// Moved to math subdirectory.
+//
+// Revision 1.2  1998/04/21 17:03:42  curt
+// Prepairing for C++ integration.
+//
+// Revision 1.1  1998/04/08 22:57:25  curt
+// Adopted Gnu automake/autoconf system.
+//
+// Revision 1.1  1998/03/19 02:54:48  curt
+// Reorganized into a class lib called fgDEM.
+//
+// Revision 1.1  1997/10/13 17:02:35  curt
+// Initial revision.
+//
@@ -0,0 +1,208 @@
+/* Copyright 1988, Brown Computer Graphics Group.  All Rights Reserved. */
+
+/* -------------------------------------------------------------------------
+		       Public MAT3 include file
+   ------------------------------------------------------------------------- */
+
+#ifndef MAT3_HAS_BEEN_INCLUDED
+#define MAT3_HAS_BEEN_INCLUDED
+
+/* -----------------------------  Constants  ------------------------------ */
+
+/*
+ * Make sure the math library .h file is included, in case it wasn't.
+ */
+
+#ifndef HUGE
+#include <math.h>
+#endif
+#include <stdio.h>
+
+#include <string.h>
+#include "Include/fg_memory.h"
+
+#ifdef __cplusplus                                                          
+extern "C" {                            
+#endif                                   
+
+
+#define MAT3_DET0	-1			/* Indicates singular mat */
+#define MAT3_EPSILON	1e-12			/* Close enough to zero   */
+
+#ifdef M_PI
+#  define  MAT3_PI    M_PI
+#else
+#  define  MAT3_PI    3.14159265358979323846
+#endif
+
+#define USE_XTRA_MAT3_INLINES
+
+/* ------------------------------  Types  --------------------------------- */
+
+typedef double MAT3mat[4][4];		/* 4x4 matrix			 */
+typedef double MAT3vec[3];		/* Vector			 */
+typedef double MAT3hvec[4];             /* Vector with homogeneous coord */
+
+/* ------------------------------  Macros  -------------------------------- */
+
+extern MAT3mat identityMatrix;
+
+/* Tests if a number is within EPSILON of zero */
+#define MAT3_IS_ZERO(N) 	((N) < MAT3_EPSILON && (N) > -MAT3_EPSILON)
+
+/* Sets a vector to the three given values */
+#define MAT3_SET_VEC(V,X,Y,Z)	((V)[0]=(X), (V)[1]=(Y), (V)[2]=(Z))
+
+/* Tests a vector for all components close to zero */
+#define MAT3_IS_ZERO_VEC(V)	(MAT3_IS_ZERO((V)[0]) && \
+				 MAT3_IS_ZERO((V)[1]) && \
+				 MAT3_IS_ZERO((V)[2]))
+
+/* Dot product of two vectors */
+#define MAT3_DOT_PRODUCT(V1,V2) \
+			((V1)[0]*(V2)[0] + (V1)[1]*(V2)[1] + (V1)[2]*(V2)[2])
+
+/* Copy one vector to other */
+#define MAT3_COPY_VEC(TO,FROM)	((TO)[0] = (FROM)[0], \
+				 (TO)[1] = (FROM)[1], \
+				 (TO)[2] = (FROM)[2])
+
+/* Normalize vector to unit length, using TEMP as temporary variable.
+ * TEMP will be zero if vector has zero length */
+#define MAT3_NORMALIZE_VEC(V,TEMP) \
+	if ((TEMP = sqrt(MAT3_DOT_PRODUCT(V,V))) > MAT3_EPSILON) { \
+	   TEMP = 1.0 / TEMP; \
+	   MAT3_SCALE_VEC(V,V,TEMP); \
+	} else TEMP = 0.0
+
+/* Scale vector by given factor, storing result vector in RESULT_V */
+#define MAT3_SCALE_VEC(RESULT_V,V,SCALE) \
+	MAT3_SET_VEC(RESULT_V, (V)[0]*(SCALE), (V)[1]*(SCALE), (V)[2]*(SCALE))
+
+/* Adds vectors V1 and V2, storing result in RESULT_V */
+#define MAT3_ADD_VEC(RESULT_V,V1,V2) \
+	MAT3_SET_VEC(RESULT_V, (V1)[0]+(V2)[0], (V1)[1]+(V2)[1], \
+			       (V1)[2]+(V2)[2])
+
+/* Subtracts vector V2 from V1, storing result in RESULT_V */
+#define MAT3_SUB_VEC(RESULT_V,V1,V2) \
+	MAT3_SET_VEC(RESULT_V, (V1)[0]-(V2)[0], (V1)[1]-(V2)[1], \
+			       (V1)[2]-(V2)[2])
+
+/* Multiplies vectors V1 and V2, storing result in RESULT_V */
+#define MAT3_MULT_VEC(RESULT_V,V1,V2) \
+	MAT3_SET_VEC(RESULT_V, (V1)[0]*(V2)[0], (V1)[1]*(V2)[1], \
+			       (V1)[2]*(V2)[2])
+
+/* Sets RESULT_V to the linear combination of V1 and V2, scaled by
+ * SCALE1 and SCALE2, respectively */
+#define MAT3_LINEAR_COMB(RESULT_V,SCALE1,V1,SCALE2,V2) \
+	MAT3_SET_VEC(RESULT_V,	(SCALE1)*(V1)[0] + (SCALE2)*(V2)[0], \
+				(SCALE1)*(V1)[1] + (SCALE2)*(V2)[1], \
+				(SCALE1)*(V1)[2] + (SCALE2)*(V2)[2])
+
+/* Several of the vector macros are useful for homogeneous-coord vectors */
+#define MAT3_SET_HVEC(V,X,Y,Z,W) ((V)[0]=(X), (V)[1]=(Y), \
+				  (V)[2]=(Z), (V)[3]=(W))
+
+#define MAT3_COPY_HVEC(TO,FROM) ((TO)[0] = (FROM)[0], \
+				 (TO)[1] = (FROM)[1], \
+				 (TO)[2] = (FROM)[2], \
+				 (TO)[3] = (FROM)[3])
+
+#define MAT3_SCALE_HVEC(RESULT_V,V,SCALE) \
+	MAT3_SET_HVEC(RESULT_V, (V)[0]*(SCALE), (V)[1]*(SCALE), \
+				(V)[2]*(SCALE), (V)[3]*(SCALE))
+
+#define MAT3_ADD_HVEC(RESULT_V,V1,V2) \
+	MAT3_SET_HVEC(RESULT_V, (V1)[0]+(V2)[0], (V1)[1]+(V2)[1], \
+				(V1)[2]+(V2)[2], (V1)[3]+(V2)[3])
+
+#define MAT3_SUB_HVEC(RESULT_V,V1,V2) \
+	MAT3_SET_HVEC(RESULT_V, (V1)[0]-(V2)[0], (V1)[1]-(V2)[1], \
+				(V1)[2]-(V2)[2], (V1)[3]-(V2)[3])
+
+#define MAT3_MULT_HVEC(RESULT_V,V1,V2) \
+	MAT3_SET_HVEC(RESULT_V, (V1)[0]*(V2)[0], (V1)[1]*(V2)[1], \
+				(V1)[2]*(V2)[2], (V1)[3]*(V2)[3])
+
+/* ------------------------------  Entries  ------------------------------- */
+
+
+#define MAT3identity(mat)    fgmemcpy( mat, identityMatrix, sizeof(MAT3mat) )
+#define MAT3zero(mat)        fgmemzero( mat, sizeof(MAT3mat) )
+#define MAT3copy(to, from)   fgmemcpy( to, from, sizeof(MAT3mat) )
+
+#if defined( USE_XTRA_MAT3_INLINES )
+
+#  define MAT3mult_vec( result_vec, vec, mat) { \
+   MAT3vec tempvec; \
+   tempvec[0]=vec[0]*mat[0][0]+vec[1]*mat[1][0]+vec[2]*mat[2][0]+mat[3][0]; \
+   tempvec[1]=vec[0]*mat[0][1]+vec[1]*mat[1][1]+vec[2]*mat[2][1]+mat[3][1]; \
+   tempvec[2]=vec[0]*mat[0][2]+vec[1]*mat[1][2]+vec[2]*mat[2][2]+mat[3][2]; \
+   result_vec[0] = tempvec[0]; \
+   result_vec[1] = tempvec[1]; \
+   result_vec[2] = tempvec[2]; \
+}
+
+#  define MAT3cross_product(result_vec, vec1, vec2)  { \
+   MAT3vec tempvec; \
+   tempvec[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1]; \
+   tempvec[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2]; \
+   tempvec[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0]; \
+   result_vec[0] = tempvec[0]; \
+   result_vec[1] = tempvec[1]; \
+   result_vec[2] = tempvec[2]; \
+} 
+
+#  define MAT3mult( result_mat,  mat1,  mat2) { \
+   register int i, j; \
+   MAT3mat	tmp_mat; \
+   for (i = 0; i < 4; i++) \
+      for (j = 0; j < 4; j++) \
+         tmp_mat[i][j] = (mat1[i][0] * mat2[0][j] + \
+			  mat1[i][1] * mat2[1][j] + \
+			  mat1[i][2] * mat2[2][j] + \
+			  mat1[i][3] * mat2[3][j]); \
+   fgmemcpy(result_mat, tmp_mat, sizeof(MAT3mat)); \
+}
+
+#else // !defined( USE_XTRA_MAT3_INLINES )
+
+/* In MAT3mat.c */
+void	MAT3mult(MAT3mat result, MAT3mat, MAT3mat);
+void	MAT3mult_vec(MAT3vec result_vec, MAT3vec vec, MAT3mat mat);
+void	MAT3cross_product(MAT3vec result,MAT3vec,MAT3vec);
+
+#endif // defined( USE_XTRA_MAT3_INLINES )
+
+/* In MAT3geom.c */
+void	MAT3direction_matrix (MAT3mat result_mat, MAT3mat mat);
+int     MAT3normal_matrix (MAT3mat result_mat, MAT3mat mat);
+void	MAT3rotate (MAT3mat result_mat, MAT3vec axis, double angle_in_radians);
+void	MAT3translate (MAT3mat result_mat, MAT3vec trans);
+void	MAT3scale (MAT3mat result_mat, MAT3vec scale);
+void	MAT3shear(MAT3mat result_mat, double xshear, double yshear);
+
+void	MAT3transpose (MAT3mat result, MAT3mat);
+int	MAT3invert (MAT3mat result, MAT3mat);
+void	MAT3print (MAT3mat, FILE *fp);
+void	MAT3print_formatted (MAT3mat, FILE *fp, 
+			     char *title, char *head, char *format, char *tail);
+int	MAT3equal( void );
+double  MAT3trace( void );
+int	MAT3power( void );
+int	MAT3column_reduce( void );
+int	MAT3kernel_basis( void );
+
+/* In MAT3vec.c */
+int	MAT3mult_hvec (MAT3hvec result_vec, MAT3hvec vec, MAT3mat mat, int normalize);
+void	MAT3perp_vec(MAT3vec result_vec, MAT3vec vec, int is_unit);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* MAT3_HAS_BEEN_INCLUDED */
+
@@ -0,0 +1,56 @@
+/* Copyright 1988, Brown Computer Graphics Group.  All Rights Reserved. */
+
+
+#ifndef _MAT3DEFS_H
+#define _MAT3DEFS_H
+
+
+#ifdef __cplusplus                                                          
+extern "C" {                            
+#endif                                   
+
+#include <stdio.h>
+/* #include <Math/mat3err.h> */
+#include <Math/mat3.h>
+
+/* -----------------------------  Constants  ------------------------------ */
+
+#define FALSE		0
+#define TRUE		1
+
+#define CNULL ((char *) NULL)
+
+/* ------------------------------  Macros  -------------------------------- */
+
+#define ALLOCN(P,T,N,M) \
+   if ((P = (T *) malloc((unsigned) (N) * sizeof(T))) == NULL) \
+      ERR_ERROR(MAT3_errid, ERR_FATAL, (ERR_ALLOC1, M)); \
+   else
+
+#define FREE(P)    free((char *) (P))
+
+#define ABS(A)		((A) > 0   ? (A) : -(A))
+#define MIN(A,B)	((A) < (B) ? (A) :  (B))
+#define MAX(A,B)	((A) > (B) ? (A) :  (B))
+
+#define SWAP(A,B,T)	(T = A, A = B, B = T)
+
+/* Is N within EPS of zero ? */
+#define IS_ZERO(N,EPS)	((N) < EPS && (N) > -EPS)
+
+/* Macros for lu routines */
+#define LU_PERMUTE(p,i,j)  { int LU_T; LU_T = p[i]; p[i] = p[j]; p[j] = LU_T; }
+
+/* -------------------------  Internal Entries ---------------------------- */
+
+/* -------------------------  Global Variables ---------------------------- */
+
+/* extern ERRid	*MAT3_errid; */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _MAT3DEFS_H */
@@ -0,0 +1,41 @@
+#ifndef _MAT3ERR_H
+#define _MAT3ERR_H
+
+
+#ifdef __cplusplus                                                          
+extern "C" {                            
+#endif                                   
+
+
+#include "sph_errtypes.h"
+
+#ifdef THINK_C
+/* We hide this from gnu's compiler, which doesn't understand it. */
+void SPH__error (int errtype, ...);
+#endif
+
+
+#define ERR_ERROR(A,B,C)   \
+   if (1) {char cstr[256]; sprintf C; SPH__error(ERR_MAT3_PACKAGE, cstr); } else
+
+
+#define ERR_S  cstr,"%s\n"
+#define ERR_SI cstr,"%s: %d\n"
+#define ERR_SS cstr,"%s: %s\n"
+
+#define ERR_SEVERE 0
+#define ERR_FATAL  0
+
+#define ERR_ALLOC1 0
+
+typedef int ERRid;
+
+#define ERRregister_package(S)    100
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _MAT3ERR_H */
@@ -0,0 +1,371 @@
+// point3d.hxx -- a 3d point class.  
+//
+// Adapted from algebra3 by Jean-Francois Doue, started October 1998.
+//
+// Copyright (C) 1998  Curtis L. Olson  - curt@me.umn.edu
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _POINT3D_HXX
+#define _POINT3D_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include "Include/compiler.h"
+
+#ifdef FG_MATH_EXCEPTION_CLASH
+# define exception c_exception
+#endif
+
+#ifdef FG_HAVE_STD_INCLUDES
+# include <iostream>
+# include <cassert>
+# include <cmath>
+#else
+# include <iostream.h>
+# include <assert.h>
+# include <math.h>
+#endif
+
+#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
+FG_USING_STD(ostream);
+FG_USING_STD(istream);
+#endif
+
+// -rp- assert.h is buggy under MWCWP3, as multiple #include undef assert !
+#ifdef __MWERKS__
+#  define assert(x)
+#endif
+
+const double fgPoint3_Epsilon = 0.0000001;
+
+enum {PX, PY, PZ};		    // axes
+
+// Kludge for msvc++ 6.0 - requires forward decls of friend functions.
+class Point3D;
+istream& operator>> ( istream&, Point3D& );
+ostream& operator<< ( ostream&, const Point3D& );
+Point3D operator- (const Point3D& p);	            // -p1
+bool operator== (const Point3D& a, const Point3D& b);  // p1 == p2?
+
+
+///////////////////////////
+//
+// 3D Point
+//
+///////////////////////////
+
+class Point3D {
+
+protected:
+
+    double n[3];
+
+public:
+
+    // Constructors
+
+    Point3D();
+    Point3D(const double x, const double y, const double z);
+    explicit Point3D(const double d);
+    Point3D(const Point3D &p);
+
+    // Assignment operators
+
+    Point3D& operator = ( const Point3D& p );	 // assignment of a Point3D
+    Point3D& operator += ( const Point3D& p );	 // incrementation by a Point3D
+    Point3D& operator -= ( const Point3D& p );	 // decrementation by a Point3D
+    Point3D& operator *= ( const double d );     // multiplication by a constant
+    Point3D& operator /= ( const double d );	 // division by a constant
+
+    void setx(const double x);
+    void sety(const double y);
+    void setz(const double z);
+
+    // Queries 
+
+    double& operator [] ( int i);		 // indexing
+    double operator[] (int i) const;		 // read-only indexing
+
+    double x() const;      // cartesian x
+    double y() const;      // cartesian y
+    double z() const;      // cartesian z
+
+    double lon() const;    // polar longitude
+    double lat() const;    // polar latitude
+    double radius() const; // polar radius
+    double elev() const;   // geodetic elevation (if specifying a surface point)
+
+    // friends
+    friend Point3D operator - (const Point3D& p);	            // -p1
+    friend bool operator == (const Point3D& a, const Point3D& b);  // p1 == p2?
+    friend istream& operator>> ( istream&, Point3D& );
+    friend ostream& operator<< ( ostream&, const Point3D& );
+
+    // Special functions
+    double distance3D(const Point3D& a) const;        // distance between
+    double distance3Dsquared(const Point3D& a) const; // distance between ^ 2
+};
+
+
+// input from stream
+inline istream&
+operator >> ( istream& in, Point3D& p)
+{
+    char c;
+
+    in >> p.n[PX];
+
+    // read past optional comma
+    while ( in.get(c) ) {
+	if ( (c != ' ') && (c != ',') ) {
+	    // push back on the stream
+	    in.putback(c);
+	    break;
+	}
+    }
+	
+    in >> p.n[PY];
+
+    // read past optional comma
+    while ( in.get(c) ) {
+	if ( (c != ' ') && (c != ',') ) {
+	    // push back on the stream
+	    in.putback(c);
+	    break;
+	}
+    }
+	
+    in >> p.n[PZ];
+
+    return in;
+}
+
+inline ostream&
+operator<< ( ostream& out, const Point3D& p )
+{
+    return out << p.n[PX] << ", " << p.n[PY] << ", " << p.n[PZ];
+}
+
+///////////////////////////
+//
+// Point3D Member functions
+//
+///////////////////////////
+
+// CONSTRUCTORS
+
+inline Point3D::Point3D() {}
+
+inline Point3D::Point3D(const double x, const double y, const double z)
+{
+    n[PX] = x; n[PY] = y; n[PZ] = z;
+}
+
+inline Point3D::Point3D(const double d)
+{
+    n[PX] = n[PY] = n[PZ] = d;
+}
+
+inline Point3D::Point3D(const Point3D& p)
+{
+    n[PX] = p.n[PX]; n[PY] = p.n[PY]; n[PZ] = p.n[PZ];
+}
+
+// ASSIGNMENT OPERATORS
+
+inline Point3D& Point3D::operator = (const Point3D& p)
+{
+    n[PX] = p.n[PX]; n[PY] = p.n[PY]; n[PZ] = p.n[PZ]; return *this;
+}
+
+inline Point3D& Point3D::operator += ( const Point3D& p )
+{
+    n[PX] += p.n[PX]; n[PY] += p.n[PY]; n[PZ] += p.n[PZ]; return *this;
+}
+
+inline Point3D& Point3D::operator -= ( const Point3D& p )
+{
+    n[PX] -= p.n[PX]; n[PY] -= p.n[PY]; n[PZ] -= p.n[PZ]; return *this;
+}
+
+inline Point3D& Point3D::operator *= ( const double d )
+{
+    n[PX] *= d; n[PY] *= d; n[PZ] *= d; return *this;
+}
+
+inline Point3D& Point3D::operator /= ( const double d )
+{
+    double d_inv = 1./d; n[PX] *= d_inv; n[PY] *= d_inv; n[PZ] *= d_inv;
+    return *this;
+}
+
+inline void Point3D::setx(const double x) {
+    n[PX] = x;
+}
+
+inline void Point3D::sety(const double y) {
+    n[PY] = y;
+}
+
+inline void Point3D::setz(const double z) {
+    n[PZ] = z;
+}
+
+// QUERIES
+
+inline double& Point3D::operator [] ( int i)
+{
+    assert(! (i < PX || i > PZ));
+    return n[i];
+}
+
+inline double Point3D::operator [] ( int i) const {
+    assert(! (i < PX || i > PZ));
+    return n[i];
+}
+
+
+inline double Point3D::x() const { return n[PX]; }
+
+inline double Point3D::y() const { return n[PY]; }
+
+inline double Point3D::z() const { return n[PZ]; }
+
+inline double Point3D::lon() const { return n[PX]; }
+
+inline double Point3D::lat() const { return n[PY]; }
+
+inline double Point3D::radius() const { return n[PZ]; }
+
+inline double Point3D::elev() const { return n[PZ]; }
+
+
+// FRIENDS
+
+inline Point3D operator - (const Point3D& a)
+{
+    return Point3D(-a.n[PX],-a.n[PY],-a.n[PZ]);
+}
+
+inline Point3D operator + (const Point3D& a, const Point3D& b)
+{
+    return Point3D(a) += b;
+}
+
+inline Point3D operator - (const Point3D& a, const Point3D& b)
+{
+    return Point3D(a) -= b;
+}
+
+inline Point3D operator * (const Point3D& a, const double d)
+{
+    return Point3D(a) *= d;
+}
+
+inline Point3D operator * (const double d, const Point3D& a)
+{
+    return a*d;
+}
+
+inline Point3D operator / (const Point3D& a, const double d)
+{
+    return Point3D(a) *= (1.0 / d );
+}
+
+inline bool operator == (const Point3D& a, const Point3D& b)
+{
+    return
+	(a.n[PX] - b.n[PX]) < fgPoint3_Epsilon &&
+	(a.n[PY] - b.n[PY]) < fgPoint3_Epsilon &&
+	(a.n[PZ] - b.n[PZ]) < fgPoint3_Epsilon;
+}
+
+inline bool operator != (const Point3D& a, const Point3D& b)
+{
+    return !(a == b);
+}
+
+// Special functions
+
+inline double
+Point3D::distance3D(const Point3D& a ) const
+{
+    double x, y, z;
+
+    x = n[PX] - a.n[PX];
+    y = n[PY] - a.n[PY];
+    z = n[PZ] - a.n[PZ];
+
+    return sqrt(x*x + y*y + z*z);
+}
+
+
+inline double
+Point3D::distance3Dsquared(const Point3D& a ) const
+{
+    double x, y, z;
+
+    x = n[PX] - a.n[PX];
+    y = n[PY] - a.n[PY];
+    z = n[PZ] - a.n[PZ];
+
+    return(x*x + y*y + z*z);
+}
+
+
+#endif // _POINT3D_HXX
+
+
+// $Log$
+// Revision 1.10  1999/03/02 01:01:52  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.9  1999/02/01 21:08:28  curt
+// Optimizations from Norman Vine.
+//
+// Revision 1.8  1999/01/27 04:46:18  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.7  1999/01/19 20:56:58  curt
+// MacOS portability changes contributed by "Robert Puyol" <puyol@abvent.fr>
+//
+// Revision 1.6  1998/11/23 21:46:37  curt
+// Borland portability tweaks.
+//
+// Revision 1.5  1998/11/20 01:00:38  curt
+// Patch in fgGeoc2Geod() to avoid a floating explosion.
+// point3d.hxx include math.h for FreeBSD
+//
+// Revision 1.4  1998/11/11 00:18:38  curt
+// Check for domain error in fgGeoctoGeod()
+//
+// Revision 1.3  1998/10/20 18:21:49  curt
+// Tweaks from Bernie Bright.
+//
+// Revision 1.2  1998/10/18 01:17:12  curt
+// Point3D tweaks.
+//
+// Revision 1.1  1998/10/16 00:50:29  curt
+// Added point3d.hxx to replace cheezy fgPoint3d struct.
+//
+//
@@ -0,0 +1,110 @@
+// polar.cxx -- routines to deal with polar math and transformations
+//
+// Written by Curtis Olson, started June 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#include <math.h>
+#include <stdio.h>
+
+#include <Include/fg_constants.h>
+
+#include "polar3d.hxx"
+
+
+// Find the Altitude above the Ellipsoid (WGS84) given the Earth
+// Centered Cartesian coordinate vector Distances are specified in
+// meters.
+double fgGeodAltFromCart(const Point3D& cp)
+{
+    double t_lat, x_alpha, mu_alpha;
+    double lat_geoc, radius;
+    double result;
+
+    lat_geoc = FG_PI_2 - atan2( sqrt(cp.x()*cp.x() + cp.y()*cp.y()), cp.z() );
+    radius = sqrt( cp.x()*cp.x() + cp.y()*cp.y() + cp.z()*cp.z() );
+	
+    if( ( (FG_PI_2 - lat_geoc) < ONE_SECOND )        // near North pole
+	|| ( (FG_PI_2 + lat_geoc) < ONE_SECOND ) )   // near South pole
+    {
+	result = radius - EQUATORIAL_RADIUS_M*E;
+    } else {
+	t_lat = tan(lat_geoc);
+	x_alpha = E*EQUATORIAL_RADIUS_M/sqrt(t_lat*t_lat + E*E);
+	mu_alpha = atan2(sqrt(RESQ_M - x_alpha*x_alpha),E*x_alpha);
+	if (lat_geoc < 0) {
+	    mu_alpha = - mu_alpha;
+	}
+	result = (radius - x_alpha/cos(lat_geoc))*cos(mu_alpha - lat_geoc);
+    }
+
+    return(result);
+}
+
+
+// $Log$
+// Revision 1.6  1999/01/27 04:46:19  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.5  1998/10/18 01:17:13  curt
+// Point3D tweaks.
+//
+// Revision 1.4  1998/10/16 19:30:09  curt
+// C++-ified the comments.
+//
+// Revision 1.3  1998/10/16 00:50:29  curt
+// Added point3d.hxx to replace cheezy fgPoint3d struct.
+//
+// Revision 1.2  1998/08/24 20:04:11  curt
+// Various "inline" code optimizations contributed by Norman Vine.
+//
+// Revision 1.1  1998/07/08 14:40:08  curt
+// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+// Updated fg_geodesy comments to reflect that routines expect and produce
+//   meters.
+//
+// Revision 1.2  1998/05/03 00:45:49  curt
+// Commented out a debugging printf.
+//
+// Revision 1.1  1998/05/02 01:50:11  curt
+// polar.[ch] renamed to polar3d.[ch]
+//
+// Revision 1.6  1998/04/25 22:06:23  curt
+// Edited cvs log messages in source files ... bad bad bad!
+//
+// Revision 1.5  1998/01/27 00:48:00  curt
+// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
+// system and commandline/config file processing code.
+//
+// Revision 1.4  1998/01/19 19:27:12  curt
+// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+// This should simplify things tremendously.
+//
+// Revision 1.3  1997/12/15 23:54:54  curt
+// Add xgl wrappers for debugging.
+// Generate terrain normals on the fly.
+//
+// Revision 1.2  1997/07/31 22:52:27  curt
+// Working on redoing internal coordinate systems & scenery transformations.
+//
+// Revision 1.1  1997/07/07 21:02:36  curt
+// Initial revision.
+
@@ -0,0 +1,120 @@
+// polar.hxx -- routines to deal with polar math and transformations
+//
+// Written by Curtis Olson, started June 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _POLAR_HXX
+#define _POLAR_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+
+#include <Include/fg_constants.h>
+#include <Math/point3d.hxx>
+
+
+// Find the Altitude above the Ellipsoid (WGS84) given the Earth
+// Centered Cartesian coordinate vector Distances are specified in
+// meters.
+double fgGeodAltFromCart(const Point3D& cp);
+
+
+// Convert a polar coordinate to a cartesian coordinate.  Lon and Lat
+// must be specified in radians.  The FG convention is for distances
+// to be specified in meters
+inline Point3D fgPolarToCart3d(const Point3D& p) {
+    double tmp = cos( p.lat() ) * p.radius();
+
+    return Point3D( cos( p.lon() ) * tmp,
+		    sin( p.lon() ) * tmp,
+		    sin( p.lat() ) * p.radius() );
+}
+
+
+// Convert a cartesian coordinate to polar coordinates (lon/lat
+// specified in radians.  Distances are specified in meters.
+inline Point3D fgCartToPolar3d(const Point3D& cp) {
+    return Point3D( atan2( cp.y(), cp.x() ),
+		    FG_PI_2 - 
+		    atan2( sqrt(cp.x()*cp.x() + cp.y()*cp.y()), cp.z() ),
+		    sqrt(cp.x()*cp.x() + cp.y()*cp.y() + cp.z()*cp.z()) );
+}
+
+
+#endif // _POLAR_HXX
+
+
+// $Log$
+// Revision 1.5  1999/01/27 04:46:20  curt
+// Portability tweaks by Bernie Bright.
+//
+// Revision 1.4  1998/10/16 19:30:07  curt
+// C++-ified the comments.
+//
+// Revision 1.3  1998/10/16 00:50:30  curt
+// Added point3d.hxx to replace cheezy fgPoint3d struct.
+//
+// Revision 1.2  1998/08/24 20:04:12  curt
+// Various "inline" code optimizations contributed by Norman Vine.
+//
+// Revision 1.1  1998/07/08 14:40:09  curt
+// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+// Updated fg_geodesy comments to reflect that routines expect and produce
+//   meters.
+//
+// Revision 1.1  1998/05/02 01:50:11  curt
+// polar.[ch] renamed to polar3d.[ch]
+//
+// Revision 1.9  1998/04/25 22:06:23  curt
+// Edited cvs log messages in source files ... bad bad bad!
+//
+// Revision 1.8  1998/04/21 17:03:50  curt
+// Prepairing for C++ integration.
+//
+// Revision 1.7  1998/01/27 00:48:00  curt
+// Incorporated Paul Bleisch's <pbleisch@acm.org> new debug message
+// system and commandline/config file processing code.
+//
+// Revision 1.6  1998/01/22 02:59:39  curt
+// Changed #ifdef FILE_H to #ifdef _FILE_H
+//
+// Revision 1.5  1998/01/19 19:27:13  curt
+// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+// This should simplify things tremendously.
+//
+// Revision 1.4  1997/12/15 23:54:55  curt
+// Add xgl wrappers for debugging.
+// Generate terrain normals on the fly.
+//
+// Revision 1.3  1997/07/31 22:52:28  curt
+// Working on redoing internal coordinate systems & scenery transformations.
+//
+// Revision 1.2  1997/07/23 21:52:21  curt
+// Put comments around the text after an #endif for increased portability.
+//
+// Revision 1.1  1997/07/07 21:02:37  curt
+// Initial revision.
+//
+
@@ -0,0 +1,162 @@
+// vector.cxx -- additional vector routines
+//
+// Written by Curtis Olson, started December 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#include <math.h>
+#include <stdio.h>
+
+// #include <Include/fg_types.h>
+
+#include "vector.hxx"
+
+#include "mat3.h"
+
+
+#if !defined( USE_XTRA_MAT3_INLINES )
+// Map a vector onto the plane specified by normal
+void map_vec_onto_cur_surface_plane(MAT3vec normal, MAT3vec v0, MAT3vec vec,
+				    MAT3vec result)
+{
+    MAT3vec u1, v, tmp;
+
+    // calculate a vector "u1" representing the shortest distance from
+    // the plane specified by normal and v0 to a point specified by
+    // "vec".  "u1" represents both the direction and magnitude of
+    // this desired distance.
+
+    // u1 = ( (normal <dot> vec) / (normal <dot> normal) ) * normal
+
+    MAT3_SCALE_VEC( u1,
+		    normal,
+		    ( MAT3_DOT_PRODUCT(normal, vec) /
+		      MAT3_DOT_PRODUCT(normal, normal)
+		      )
+		    );
+
+    // printf("  vec = %.2f, %.2f, %.2f\n", vec[0], vec[1], vec[2]);
+    // printf("  v0 = %.2f, %.2f, %.2f\n", v0[0], v0[1], v0[2]);
+    // printf("  u1 = %.2f, %.2f, %.2f\n", u1[0], u1[1], u1[2]);
+   
+    // calculate the vector "v" which is the vector "vec" mapped onto
+    // the plane specified by "normal" and "v0".
+
+    // v = v0 + vec - u1
+
+    MAT3_ADD_VEC(tmp, v0, vec);
+    MAT3_SUB_VEC(v, tmp, u1);
+    // printf("  v = %.2f, %.2f, %.2f\n", v[0], v[1], v[2]);
+
+    // Calculate the vector "result" which is "v" - "v0" which is a
+    // directional vector pointing from v0 towards v
+
+    // result = v - v0
+
+    MAT3_SUB_VEC(result, v, v0);
+    // printf("  result = %.2f, %.2f, %.2f\n", 
+    // result[0], result[1], result[2]);
+}
+#endif // !defined( USE_XTRA_MAT3_INLINES )
+
+
+// Given a point p, and a line through p0 with direction vector d,
+// find the shortest distance from the point to the line
+double fgPointLine(MAT3vec p, MAT3vec p0, MAT3vec d) {
+    MAT3vec u, u1, v;
+    double ud, dd, tmp;
+    
+    // u = p - p0
+    MAT3_SUB_VEC(u, p, p0);
+
+    // calculate the projection, u1, of u along d.
+    // u1 = ( dot_prod(u, d) / dot_prod(d, d) ) * d;
+    ud = MAT3_DOT_PRODUCT(u, d);
+    dd = MAT3_DOT_PRODUCT(d, d);
+    tmp = ud / dd;
+
+    MAT3_SCALE_VEC(u1, d, tmp);;
+
+    // v = u - u1 = vector from closest point on line, p1, to the
+    // original point, p.
+    MAT3_SUB_VEC(v, u, u1);
+
+    return sqrt(MAT3_DOT_PRODUCT(v, v));
+}
+
+
+// Given a point p, and a line through p0 with direction vector d,
+// find the shortest distance (squared) from the point to the line
+double fgPointLineSquared(MAT3vec p, MAT3vec p0, MAT3vec d) {
+    MAT3vec u, u1, v;
+    double ud, dd, tmp;
+    
+    // u = p - p0
+    MAT3_SUB_VEC(u, p, p0);
+
+    // calculate the projection, u1, of u along d.
+    // u1 = ( dot_prod(u, d) / dot_prod(d, d) ) * d;
+    ud = MAT3_DOT_PRODUCT(u, d);
+    dd = MAT3_DOT_PRODUCT(d, d);
+    tmp = ud / dd;
+
+    MAT3_SCALE_VEC(u1, d, tmp);;
+
+    // v = u - u1 = vector from closest point on line, p1, to the
+    // original point, p.
+    MAT3_SUB_VEC(v, u, u1);
+
+    return ( MAT3_DOT_PRODUCT(v, v) );
+}
+
+
+// $Log$
+// Revision 1.6  1999/03/25 19:02:28  curt
+// Minor optimization tweaks.
+//
+// Revision 1.5  1998/10/16 23:36:38  curt
+// c++-ifying.
+//
+// Revision 1.4  1998/10/16 00:50:31  curt
+// Added point3d.hxx to replace cheezy fgPoint3d struct.
+//
+// Revision 1.3  1998/08/24 20:04:12  curt
+// Various "inline" code optimizations contributed by Norman Vine.
+//
+// Revision 1.2  1998/07/24 21:34:38  curt
+// fgPointLine() rewritten into fgPointLineSquared() ... this ultimately saves
+// us from doing a sqrt().
+//
+// Revision 1.1  1998/07/08 14:40:10  curt
+// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+// Updated fg_geodesy comments to reflect that routines expect and produce
+//   meters.
+//
+// Revision 1.3  1998/05/07 23:04:28  curt
+// Added a blank formating line!
+//
+// Revision 1.2  1998/01/19 19:27:13  curt
+// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+// This should simplify things tremendously.
+//
+// Revision 1.1  1997/12/22 04:13:17  curt
+// Initial revision.
+//
@@ -0,0 +1,94 @@
+// vector.hxx -- additional vector routines
+//
+// Written by Curtis Olson, started December 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _VECTOR_HXX
+#define _VECTOR_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+
+#include "mat3.h"
+
+
+// Map a vector onto the plane specified by normal
+#if defined( USE_XTRA_MAT3_INLINES )
+#  define map_vec_onto_cur_surface_plane(normal, v0, vec, result) { \
+	double scale = ((normal[0]*vec[0]+normal[1]*vec[1]+normal[2]*vec[2]) / \
+	       (normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2])); \
+	result[0] = vec[0]-normal[0]*scale; \
+	result[1] = vec[1]-normal[1]*scale; \
+	result[2] = vec[2]-normal[2]*scale; \
+  }
+#else
+  void map_vec_onto_cur_surface_plane(MAT3vec normal, MAT3vec v0, MAT3vec vec,
+				    MAT3vec result);
+#endif //defined( USE_XTRA_MAT3_INLINES )
+
+
+// Given a point p, and a line through p0 with direction vector d,
+// find the shortest distance from the point to the line
+double fgPointLine(MAT3vec p, MAT3vec p0, MAT3vec d);
+
+
+// Given a point p, and a line through p0 with direction vector d,
+// find the shortest distance (squared) from the point to the line
+double fgPointLineSquared(MAT3vec p, MAT3vec p0, MAT3vec d);
+
+
+#endif // _VECTOR_HXX
+
+
+// $Log$
+// Revision 1.4  1998/10/16 23:36:39  curt
+// c++-ifying.
+//
+// Revision 1.3  1998/08/24 20:04:13  curt
+// Various "inline" code optimizations contributed by Norman Vine.
+//
+// Revision 1.2  1998/07/24 21:34:38  curt
+// fgPointLine() rewritten into fgPointLineSquared() ... this ultimately saves
+// us from doing a sqrt().
+//
+// Revision 1.1  1998/07/08 14:40:10  curt
+// polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx
+// Updated fg_geodesy comments to reflect that routines expect and produce
+//   meters.
+//
+// Revision 1.4  1998/04/21 17:03:51  curt
+// Prepairing for C++ integration.
+//
+// Revision 1.3  1998/01/22 02:59:39  curt
+// Changed #ifdef FILE_H to #ifdef _FILE_H
+//
+// Revision 1.2  1998/01/19 19:27:14  curt
+// Merged in make system changes from Bob Kuehne <rpk@sgi.com>
+// This should simplify things tremendously.
+//
+// Revision 1.1  1997/12/22 04:13:18  curt
+// Initial revision.
+//
+
@@ -0,0 +1,16 @@
+The following files were unashamedly borrowed from other projects:
+
+zfstream.hxx
+zfstream.cxx
+	zlib/contrib/iostream
+
+stopwatch.hxx was (blitz/time.h)
+	blitz
+
+Some modifications have been made to fit in with the FlightGear scheme of things.
+
+As far as I'm aware they are all covered by GNU's licensing agreements.
+
+Many thanks to their respective authors.
+
+Bernie Bright (bbright@c031.aone.net.au)
@@ -0,0 +1,11 @@
+## Process this file with automake to produce Makefile.in
+
+noinst_LIBRARIES = libMisc.a
+
+libMisc_a_SOURCES = \
+	fgstream.cxx fgstream.hxx \
+	stopwatch.hxx \
+	strutils.cxx strutils.hxx \
+	zfstream.cxx zfstream.hxx
+
+INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib
@@ -0,0 +1,151 @@
+// zlib input file stream wrapper.
+//
+// Written by Bernie Bright, 1998
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#include <ctype.h> // isspace()
+#include <Misc/fgstream.hxx>
+
+fg_gzifstream::fg_gzifstream()
+    : istream(&gzbuf)
+{
+}
+
+//-----------------------------------------------------------------------------
+//
+// Open a possibly gzipped file for reading.
+//
+fg_gzifstream::fg_gzifstream( const string& name, ios_openmode io_mode )
+    : istream(&gzbuf)
+{
+    this->open( name, io_mode );
+}
+
+//-----------------------------------------------------------------------------
+//
+// Attach a stream to an already opened file descriptor.
+//
+fg_gzifstream::fg_gzifstream( int fd, ios_openmode io_mode )
+    : istream(&gzbuf)
+{
+    gzbuf.attach( fd, io_mode );
+}
+
+//-----------------------------------------------------------------------------
+//
+// Open a possibly gzipped file for reading.
+// If the initial open fails and the filename has a ".gz" extension then
+// remove the extension and try again.
+// If the initial open fails and the filename doesn't have a ".gz" extension
+// then append ".gz" and try again.
+//
+void
+fg_gzifstream::open( const string& name, ios_openmode io_mode )
+{
+    gzbuf.open( name.c_str(), io_mode );
+    if ( ! gzbuf.is_open() )
+    {
+	string s = name;
+	if ( s.substr( s.length() - 3, 3 ) == ".gz" )
+	{
+	    // remove ".gz" suffix
+	    s.replace( s.length() - 3, 3, "" );
+// 	    s.erase( s.length() - 3, 3 );
+	}
+	else
+	{
+	    // Append ".gz" suffix
+	    s += ".gz";
+	}
+
+	// Try again.
+	gzbuf.open( s.c_str(), io_mode );
+    }
+}
+
+void
+fg_gzifstream::attach( int fd, ios_openmode io_mode )
+{
+    gzbuf.attach( fd, io_mode );
+}
+
+//
+// Manipulators
+//
+
+istream&
+skipeol( istream& in )
+{
+    char c = 0;
+    // skip to end of line.
+    while ( in.get(c) && (c != '\n' && c != '\r') )
+	;
+
+    // \r\n ?
+    return in;
+}
+
+istream&
+skipws( istream& in )
+{
+    char c;
+    while ( in.get(c) )
+    {
+	if ( ! isspace( c ) )
+	{
+	    // put pack the non-space character
+	    in.putback(c);
+	    break;
+	}
+    }
+    return in;
+}
+
+istream&
+skipcomment( istream& in )
+{
+    while ( in )
+    {
+	// skip whitespace
+	in >> skipws;
+
+	char c;
+	if ( in.get( c ) && c != '#' )
+	{
+	    // not a comment
+	    in.putback(c);
+	    break;
+	}
+	in >> skipeol;
+    }
+    return in;
+}
+
+// $Log$
+// Revision 1.3  1998/11/06 14:05:12  curt
+// More portability improvements by Bernie Bright.
+//
+// Revision 1.2  1998/09/24 15:22:17  curt
+// Additional enhancements.
+//
+// Revision 1.1  1998/09/01 19:06:29  curt
+// Initial revision.
+//
@@ -0,0 +1,129 @@
+// zlib input file stream wrapper.
+//
+// Written by Bernie Bright, 1998
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#ifndef _FGSTREAM_HXX
+#define _FGSTREAM_HXX
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#ifdef HAVE_CONFIG_H
+#  include "Include/config.h"
+#endif
+
+#include <Include/compiler.h>
+
+#if defined( FG_HAVE_STD_INCLUDES )
+#  include <istream>
+#elif defined ( FG_HAVE_NATIVE_SGI_COMPILERS )
+#  include <CC/stream.h>
+#else
+#  include <istream.h>
+#endif
+
+#include STL_STRING
+
+#include "zfstream.hxx"
+
+FG_USING_STD(string);
+
+#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
+FG_USING_STD(istream);
+#endif
+
+
+//-----------------------------------------------------------------------------
+//
+// Envelope class for gzifstream.
+//
+class fg_gzifstream : private gzifstream_base, public istream
+{
+public:
+    //
+    fg_gzifstream();
+
+    // Attempt to open a file with and without ".gz" extension.
+    fg_gzifstream( const string& name,
+		   ios_openmode io_mode = ios_in | ios_binary );
+
+    // 
+    fg_gzifstream( int fd, ios_openmode io_mode = ios_in|ios_binary );
+
+    // Attempt to open a file with and without ".gz" extension.
+    void open( const string& name,
+	       ios_openmode io_mode = ios_in|ios_binary );
+
+    void attach( int fd, ios_openmode io_mode = ios_in|ios_binary );
+
+    void close() { gzbuf.close(); }
+
+    bool is_open() { return gzbuf.is_open(); }
+
+private:
+    // Not defined!
+    fg_gzifstream( const fg_gzifstream& );    
+    void operator= ( const fg_gzifstream& );    
+};
+
+// istream manipulator that skips to end of line.
+istream& skipeol( istream& in );
+
+// istream manipulator that skips over white space.
+istream& skipws( istream& in );
+
+// istream manipulator that skips comments and white space.
+// A comment starts with '#'.
+istream& skipcomment( istream& in );
+
+
+#endif /* _FGSTREAM_HXX */
+
+// $Log$
+// Revision 1.9  1999/03/27 14:04:25  curt
+// Added is_open() so we can check if the open() succeeded.
+//
+// Revision 1.8  1999/03/02 01:01:55  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.7  1999/02/26 22:08:08  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.6  1999/01/19 20:41:46  curt
+// Portability updates contributed by Bernie Bright.
+//
+// Revision 1.5  1998/11/06 14:05:13  curt
+// More portability improvements by Bernie Bright.
+//
+// Revision 1.4  1998/10/16 00:50:56  curt
+// Remove leading _ from a couple defines.
+//
+// Revision 1.3  1998/10/13 00:10:06  curt
+// More portability changes to help with windoze compilation problems.
+//
+// Revision 1.2  1998/09/24 15:22:18  curt
+// Additional enhancements.
+//
+// Revision 1.1  1998/09/01 19:06:29  curt
+// Initial revision.
+//
@@ -0,0 +1,141 @@
+/***************************************************************************
+ * stopwatch.hxx        Timer class, for use in benchmarking
+ *
+ * Based on blitz/Timer.h
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997,1998 Todd Veldhuizen <tveldhui@seurat.uwaterloo.ca>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Suggestions:          blitz-suggest@cybervision.com
+ * Bugs:                 blitz-bugs@cybervision.com
+ *
+ * For more information, please see the Blitz++ Home Page:
+ *    http://seurat.uwaterloo.ca/blitz/
+ *
+ ***************************************************************************
+ * $Log$
+ * Revision 1.3  1998/11/20 01:01:03  curt
+ * FreeBSD support.
+ *
+ * Revision 1.2  1998/11/02 18:28:31  curt
+ * Additional win32 support.
+ *
+ * Revision 1.1  1998/09/01 19:06:30  curt
+ * Initial revision.
+ *
+ * Revision 1.4  1998/03/14 00:04:47  tveldhui
+ * 0.2-alpha-05
+ *
+ * Revision 1.3  1997/07/16 14:51:20  tveldhui
+ * Update: Alpha release 0.2 (Arrays)
+ *
+ * Revision 1.2  1997/01/24 14:42:00  tveldhui
+ * Periodic RCS update
+ *
+ */
+
+// This class is not portable to non System V platforms.
+// It will need to be rewritten for Windows, NT, Mac.
+// NEEDS_WORK
+
+#ifndef _STOPWATCH_HXX
+#define _STOPWATCH_HXX
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#if defined(__linux__) && ! defined(HAVE_GETRUSAGE)
+#  define HAVE_GETRUSAGE
+#endif
+
+#if defined( WIN32 ) && defined( HAVE_GETRUSAGE )
+#  undef HAVE_GETRUSAGE
+#endif // WIN32
+
+#if defined( HAVE_GETRUSAGE )
+#  if defined( __FreeBSD__ )
+#    include <sys/types.h>
+#  endif 
+#  include <sys/time.h>
+#  include <sys/resource.h>
+#  include <unistd.h>
+#elif defined( WIN32 )
+#  include <windows.h>
+#else
+#  include <time.h>
+#endif
+
+class StopWatch {
+
+public:
+    StopWatch() 
+    { 
+//         state_ = uninitialized;
+    }
+
+    void start()
+    { 
+//         state_ = running;
+        t1_ = systemTime();
+    }
+
+    void stop()
+    {
+        t2_ = systemTime();
+// 	BZPRECONDITION(state_ == running);
+// 	state_ = stopped;
+    }
+
+    double elapsedSeconds()
+    {
+//         BZPRECONDITION(state_ == stopped);
+        return t2_ - t1_;
+    }
+
+private:
+    StopWatch(StopWatch&) { }
+    void operator=(StopWatch&) { }
+
+    double systemTime()
+    {
+#if defined( HAVE_GETRUSAGE )
+        getrusage(RUSAGE_SELF, &resourceUsage_);
+        double seconds = resourceUsage_.ru_utime.tv_sec 
+            + resourceUsage_.ru_stime.tv_sec;
+        double micros  = resourceUsage_.ru_utime.tv_usec 
+            + resourceUsage_.ru_stime.tv_usec;
+        return seconds + micros/1.0e6;
+#elif defined( WIN32 )
+	return double(GetTickCount()) * double(1e-3);
+#else
+        return clock() / (double) CLOCKS_PER_SEC;
+#endif
+    }
+
+//     enum { uninitialized, running, stopped } state_;
+
+#if defined( HAVE_GETRUSAGE )
+    struct rusage resourceUsage_;
+#endif
+
+    double t1_, t2_;
+};
+
+#endif // _STOPWATCH_HXX
+
@@ -0,0 +1,79 @@
+// String utilities.
+//
+// Written by Bernie Bright, 1998
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "strutils.hxx"
+
+const string whitespace = " \n\r\t";
+
+//
+string
+trimleft( const string& s, const string& trimmings )
+{
+    string result;
+    string::size_type pos = s.find_first_not_of( trimmings );
+    if ( pos != string::npos )
+    {
+        result.assign( s.substr( pos ) );
+    }
+
+    return result;
+}
+
+//
+string
+trimright( const string& s, const string& trimmings )
+{
+    string result;
+
+    string::size_type pos = s.find_last_not_of( trimmings );
+    if ( pos == string::npos )
+    {
+	// Not found, return the original string.
+	result = s;
+    }
+    else
+    {
+        result.assign( s.substr( 0, pos+1 ) );
+    }
+
+    return result;
+}
+
+//
+string
+trim( const string& s, const string& trimmings )
+{
+    return trimright( trimleft( s, trimmings ), trimmings );
+}
+
+// $Log$
+// Revision 1.2  1998/10/18 01:17:15  curt
+// Point3D tweaks.
+//
+// Revision 1.1  1998/09/01 19:06:30  curt
+// Initial revision.
+//
@@ -0,0 +1,84 @@
+// String utilities.
+//
+// Written by Bernie Bright, 1998
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#ifndef STRUTILS_H
+#define STRUTILS_H
+
+#include <Include/compiler.h>
+#include STL_STRING
+
+#ifdef FG_HAVE_STD_INCLUDES
+#  include <cstdlib>
+#else
+#  include <stdlib.h>
+#endif
+
+FG_USING_STD(string);
+
+// Default characters to remove.
+extern const string whitespace;
+
+// Returns a string with trailing characters removed.
+string trimleft( const string& s, const string& trimmings = whitespace );
+
+// Returns a string with leading characters removed.
+string trimright( const string& s, const string& trimmings = whitespace );
+
+// Returns a string with leading and trailing characters removed.
+string trim( const string& s, const string& trimmings = whitespace );
+
+//-----------------------------------------------------------------------------
+
+inline double
+atof( const string& str )
+{
+    return ::atof( str.c_str() );
+}
+
+inline int
+atoi( const string& str )
+{
+    return ::atoi( str.c_str() );
+}
+
+#endif // STRUTILS_H
+
+// $Log$
+// Revision 1.6  1999/03/02 01:01:56  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.5  1999/02/26 22:08:09  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.4  1999/01/19 20:41:47  curt
+// Portability updates contributed by Bernie Bright.
+//
+// Revision 1.3  1998/10/16 00:50:57  curt
+// Remove leading _ from a couple defines.
+//
+// Revision 1.2  1998/10/13 00:10:07  curt
+// More portability changes to help with windoze compilation problems.
+//
+// Revision 1.1  1998/09/01 19:06:31  curt
+// Initial revision.
+//
@@ -0,0 +1,317 @@
+//  A C++ I/O streams interface to the zlib gz* functions
+//
+// Written by Bernie Bright, 1998
+// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#include <memory.h>
+#include "zfstream.hxx"
+
+//
+// Construct a gzfilebuf object.
+// Allocate memory for 'get' buffer and zero all buffer pointers.
+//
+gzfilebuf::gzfilebuf()
+    : streambuf(),
+      file(NULL),
+      mode(0),
+      own_file_descriptor(false),
+      ibuf_size(0),
+      ibuffer(0)
+{
+//     try {
+    ibuf_size = page_size / sizeof(char);
+    ibuffer = new char [ibuf_size];
+//     } catch (...) {
+// 	delete [] ibuffer;
+//     }
+
+    // Null get and set pointers.
+    this->setg(0,0,0);
+    this->setp(0,0);
+}
+
+gzfilebuf::~gzfilebuf()
+{
+    sync();
+    if ( own_file_descriptor )
+	this->close();
+    delete [] ibuffer;
+}
+
+void
+gzfilebuf::cvt_iomode( char* p, ios_openmode io_mode )
+{
+//     memset( char_mode, '\0', 10 );
+//     char* p = char_mode;
+
+    if ( io_mode & ios_in )
+    {
+	mode = ios_in;
+	*p++ = 'r';
+    }
+    else if ( io_mode & ios_app )
+    {
+	mode = ios_app;
+	*p++ = 'a';
+    }
+    else
+    {
+	mode = ios_out;
+	*p++ = 'w';
+    }
+
+    if ( io_mode & ios_binary )
+    {
+	mode |= ios_binary;
+	*p++ = 'b';
+    }
+
+    // Hard code the compression level
+    if ( io_mode & (ios_out | ios_app) )
+    {
+	*p++ = '9';
+    }
+
+    *p = '\0';
+}
+
+gzfilebuf*
+gzfilebuf::open( const char *name, ios_openmode io_mode )
+{
+    if ( is_open() )
+	return NULL;
+
+    char char_mode[10];
+    cvt_iomode( char_mode, io_mode );
+    if ( (file = gzopen(name, char_mode)) == NULL )
+	return NULL;
+
+    own_file_descriptor = true;
+
+    return this;
+}
+
+gzfilebuf*
+gzfilebuf::attach( int file_descriptor, ios_openmode io_mode )
+{
+    if ( is_open() )
+	return NULL;
+
+    char char_mode[10];
+    cvt_iomode( char_mode, io_mode );
+    if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
+	return NULL;
+
+    own_file_descriptor = false;
+
+    return this;
+}
+
+gzfilebuf*
+gzfilebuf::close()
+{
+    if ( is_open() )
+    {
+	sync();
+	gzclose( file );
+	file = NULL;
+    }
+
+    return this;
+}
+
+// int
+// gzfilebuf::setcompressionlevel( int comp_level )
+// {
+//     return gzsetparams(file, comp_level, -2);
+// }
+
+// int
+// gzfilebuf::setcompressionstrategy( int comp_strategy )
+// {
+//     return gzsetparams(file, -2, comp_strategy);
+// }
+
+
+streampos
+gzfilebuf::seekoff( streamoff, ios_seekdir, int )
+{
+    return streampos(EOF);
+}
+
+gzfilebuf::int_type
+gzfilebuf::overflow( int_type )
+{
+#if 0
+    if ( !is_open() || !(mode & ios::out) )
+	return EOF;
+
+    if ( !base() )
+    {
+	if ( allocate() == EOF )
+	    return EOF;
+	setg(0,0,0);
+    }
+    else
+    {
+	if (in_avail())
+	{
+	    return EOF;
+	}
+
+	if (out_waiting())
+	{
+	    if (flushbuf() == EOF)
+		return EOF;
+	}
+    }
+
+    int bl = blen();
+    setp( base(), base() + bl);
+
+    if ( c != EOF )
+    {
+	*pptr() = c;
+	pbump(1);
+    }
+#endif
+    return 0;
+}
+
+int
+gzfilebuf::sync()
+{
+    if ( !is_open() )
+	return EOF;
+
+    if ( pptr() != 0 && pptr() > pbase() )
+	return flushbuf();
+
+    return 0;
+}
+
+gzfilebuf::int_type
+gzfilebuf::flushbuf()
+{
+    char* q = pbase();
+    int n = pptr() - q;
+
+    if ( gzwrite( file, q, n) < n )
+	return traits_type::eof();
+
+    setp(0,0);
+
+    return 0;
+}
+
+gzfilebuf::int_type
+gzfilebuf::underflow()
+{
+//     cerr << "gzfilebuf::underflow(): gptr()=" << (void*)gptr() << endl;
+    // Error if the file not open for reading.
+    if ( !is_open() || !(mode & ios_in) )
+	return traits_type::eof();
+
+    // If the input buffer is empty then try to fill it.
+    if ( gptr() != 0 && gptr() < egptr() )
+    {
+	return int_type(*gptr());
+    }
+    else
+    {
+	return fillbuf() == EOF ? traits_type::eof() : int_type(*gptr());
+    }
+}
+
+//
+// Load the input buffer from the underlying gz file.
+// Returns number of characters read, or EOF.
+//
+int
+gzfilebuf::fillbuf()
+{
+    int t = gzread( file, ibuffer, ibuf_size );
+    if ( t <= 0)
+    {
+	// disable get area
+	setg(0,0,0);
+	return EOF;
+    }
+
+    // Set the input (get) pointers
+    setg( ibuffer, ibuffer, ibuffer+t );
+
+//     cerr << "gzfilebuf::fillbuf():"
+// 	 << " t=" << t
+// 	 << ", ibuffer=" << (void*)ibuffer
+// 	 << ", ibuffer+t=" << (void*)(ibuffer+t) << endl;
+
+    return t;
+}
+
+#if 0
+gzifstream::gzifstream()
+    : istream(&buffer), buffer()
+{
+    clear( ios_badbit );
+}
+
+gzifstream::gzifstream( const char *name, ios_openmode io_mode )
+    : istream(&buffer), buffer()
+{
+    this->open( name, io_mode );
+}
+
+gzifstream::gzifstream( int fd, ios_openmode io_mode )
+    : istream(&buffer), buffer()
+{
+    buffer.attach( fd, io_mode );
+}
+
+gzifstream::~gzifstream()
+{
+}
+
+void
+gzifstream::open( const char *name, ios_openmode io_mode )
+{
+    if ( !buffer.open( name, io_mode ) )
+	clear( ios_failbit | ios_badbit );
+    else
+	clear();
+}
+
+void
+gzifstream::close()
+{
+    if ( !buffer.close() )
+	clear( ios_failbit | ios_badbit );
+}
+#endif
+
+// $Log$
+// Revision 1.3  1999/01/19 20:41:48  curt
+// Portability updates contributed by Bernie Bright.
+//
+// Revision 1.2  1998/11/06 14:05:14  curt
+// More portability improvements by Bernie Bright.
+//
@@ -0,0 +1,177 @@
+//  A C++ I/O streams interface to the zlib gz* functions
+//
+// Written by Bernie Bright, 1998
+// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+//
+// Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+#ifndef _zfstream_hxx
+#define _zfstream_hxx
+
+#include "zlib/zlib.h"
+#include "Include/compiler.h"
+
+#ifdef FG_HAVE_STD_INCLUDES
+
+#  include <streambuf>
+#  include <istream>
+
+#  define ios_openmode ios_base::openmode
+#  define ios_in       ios_base::in
+#  define ios_out      ios_base::out
+#  define ios_app      ios_base::app
+#  define ios_binary   ios_base::binary
+
+#  define ios_seekdir  ios_base::seekdir
+
+#  define ios_badbit   ios_base::badbit
+#  define ios_failbit  ios_base::failbit
+
+FG_USING_STD(streambuf);
+FG_USING_STD(ios_base);
+FG_USING_STD(streampos);
+FG_USING_STD(streamoff);
+
+#else
+
+#  ifdef FG_HAVE_STREAMBUF
+#    include <streambuf.h>
+#    include <istream.h>
+#  else
+#    include <iostream.h>
+#  endif
+
+//#  define ios_openmode ios::open_mode
+#  define ios_openmode int
+#  define ios_in       ios::in
+#  define ios_out      ios::out
+#  define ios_app      ios::app
+
+#if defined(__GNUC__) && __GNUC_MINOR__ < 8
+#  define ios_binary   ios::bin
+#elif defined( FG_HAVE_NATIVE_SGI_COMPILERS )
+#  define ios_binary   0
+#else
+#  define ios_binary   ios::binary
+#endif
+
+#  define ios_seekdir  ios::seek_dir
+
+#  define ios_badbit   ios::badbit
+#  define ios_failbit  ios::failbit
+
+#  include "Include/fg_traits.hxx"
+
+#endif // FG_HAVE_STD_INCLUDES
+
+//-----------------------------------------------------------------------------
+//
+//
+//
+class gzfilebuf : public streambuf
+{
+public:
+
+#ifndef FG_HAVE_STD_INCLUDES
+    typedef char_traits<char>           traits_type;
+    typedef char_traits<char>::int_type int_type;
+    typedef char_traits<char>::pos_type pos_type;
+    typedef char_traits<char>::off_type off_type;
+#endif
+
+    gzfilebuf();
+    virtual ~gzfilebuf();
+
+    gzfilebuf* open( const char* name, ios_openmode io_mode );
+    gzfilebuf* attach( int file_descriptor, ios_openmode io_mode );
+    gzfilebuf* close();
+
+//     int setcompressionlevel( int comp_level );
+//     int setcompressionstrategy( int comp_strategy );
+    bool is_open() const { return (file != NULL); }
+    virtual streampos seekoff( streamoff off, ios_seekdir way, int which );
+    virtual int sync();
+
+protected:
+
+    virtual int_type underflow();
+    virtual int_type overflow( int_type c = traits_type::eof() );
+
+private:
+
+    int_type flushbuf();
+    int fillbuf();
+
+    // Convert io_mode to "rwab" string.
+    void cvt_iomode( char* mode_str, ios_openmode io_mode );
+
+private:
+
+    gzFile file;
+    ios_openmode mode;
+    bool own_file_descriptor;
+
+    // Get (input) buffer.
+    int ibuf_size;
+    char* ibuffer;
+
+    enum { page_size = 4096 };
+
+private:
+    // Not defined
+    gzfilebuf( const gzfilebuf& );
+    void operator= ( const gzfilebuf& );
+};
+
+//-----------------------------------------------------------------------------
+//
+// 
+//
+struct gzifstream_base
+{
+    gzifstream_base() {}
+
+    gzfilebuf gzbuf;
+};
+
+#endif // _zfstream_hxx
+
+// $Log$
+// Revision 1.9  1999/03/08 22:00:12  curt
+// Tweak for native SGI compilers.
+//
+// Revision 1.8  1999/02/26 22:08:10  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.7  1999/01/19 20:41:49  curt
+// Portability updates contributed by Bernie Bright.
+//
+// Revision 1.6  1998/12/07 21:10:26  curt
+// Portability improvements.
+//
+// Revision 1.5  1998/11/06 21:17:29  curt
+// Converted to new logstream debugging facility.  This allows release
+// builds with no messages at all (and no performance impact) by using
+// the -DFG_NDEBUG flag.
+//
+// Revision 1.4  1998/11/06 14:05:16  curt
+// More portability improvements by Bernie Bright.
+//
+
@@ -0,0 +1,24 @@
+noinst_LIBRARIES = libPUI.a
+
+EXTRA_DIST = complex.cxx simple.cxx
+
+libPUI_a_SOURCES = \
+	pu.h puLocal.h \
+	pu.cxx \
+	puBox.cxx \
+	puButton.cxx \
+	puButtonBox.cxx \
+	puDialogBox.cxx \
+	puFrame.cxx \
+	puInput.cxx \
+	puInterface.cxx \
+	puMenuBar.cxx \
+	puObject.cxx \
+	puOneShot.cxx \
+	puPopup.cxx \
+	puPopupMenu.cxx \
+	puSlider.cxx \
+	puText.cxx
+
+INCLUDES += -I$(top_builddir)
+
@@ -0,0 +1,332 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+#include <math.h>
+#include <GL/glut.h>
+#include "pu.h"
+
+/***********************************\
+*                                   *
+* These are the PUI widget pointers *
+*                                   *
+\***********************************/
+
+puMenuBar   *main_menu_bar ;
+puButton    *hide_menu_button ;
+puDialogBox *dialog_box ;
+puText      *dialog_box_message ;
+puOneShot   *dialog_box_ok_button ;
+puText      *timer_text ;
+puSlider    *rspeedSlider;
+
+
+/***********************************\
+*                                   *
+*  This is a generic tumbling cube  *
+*                                   *
+\***********************************/
+
+GLfloat light_diffuse [] = {0.0, 1.0, 0.0, 1.0} ;  /* Red diffuse light. */
+GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0} ;  /* Infinite light location. */
+
+GLfloat cube_n[6][3] =  /* Normals */
+{
+ {-1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {1.0, 0.0, 0.0},
+ { 0.0,-1.0, 0.0}, {0.0, 0.0, 1.0}, {0.0, 0.0,-1.0}
+} ;
+
+GLint cube_i[6][4] =  /* Vertex indices */
+{
+  {0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4},
+  {4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3}
+} ;
+
+GLfloat cube_v[8][3] =  /* Vertices */
+{
+  {-1.0,-1.0, 1.0}, {-1.0,-1.0,-1.0}, {-1.0, 1.0,-1.0}, {-1.0, 1.0, 1.0},
+  { 1.0,-1.0, 1.0}, { 1.0,-1.0,-1.0}, { 1.0, 1.0,-1.0}, { 1.0, 1.0, 1.0}
+} ;
+
+
+static int firsttime;
+
+void drawCube (void)
+{
+
+  if ( firsttime )
+  {
+    /*
+      Deliberately do this only once - it's a better test of
+      PUI's attempts to leave the OpenGL state undisturbed
+    */
+
+    firsttime = FALSE ;
+    glLightfv      ( GL_LIGHT0, GL_DIFFUSE , light_diffuse  ) ;
+    glLightfv      ( GL_LIGHT0, GL_POSITION, light_position ) ;
+    glEnable       ( GL_LIGHT0     ) ;
+    glEnable       ( GL_LIGHTING   ) ;
+    glEnable       ( GL_DEPTH_TEST ) ;
+    glMatrixMode   ( GL_PROJECTION ) ;
+    gluPerspective ( 40.0, 1.0, 1.0, 10.0 ) ;
+    glMatrixMode   ( GL_MODELVIEW ) ;
+    gluLookAt      ( 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 ) ;
+    glTranslatef   ( 0.0, 0.0, -1.0 ) ;
+    glRotatef      ( 60.0, 1.0, 0.0, 0.0 ) ;
+  }
+
+  glCullFace     ( GL_FRONT ) ;
+  glEnable       ( GL_CULL_FACE ) ;
+  //  glRotatef ( 1.0f, 0.0, 0.0, 1.0 ) ;  /* Tumble that cube! */
+
+  glBegin ( GL_QUADS ) ;
+
+  for ( int i = 0 ; i < 6 ; i++ )
+  {
+    glNormal3fv ( &cube_n[i][0] ) ;
+    glVertex3fv ( cube_v[cube_i[i][0]] ) ; glVertex3fv ( cube_v[cube_i[i][1]] ) ;
+    glVertex3fv ( cube_v[cube_i[i][2]] ) ; glVertex3fv ( cube_v[cube_i[i][3]] ) ;
+  }
+
+  glEnd () ;
+}
+
+/********************************\
+*                                *
+* End of cube renderer in OpenGL * 
+*                                *
+\********************************/
+
+
+/**************************************\
+*                                      *
+* These three functions capture mouse  *
+* and keystrokes (special and mundane) *
+* from GLUT and pass them on to PUI.   *
+*                                      *
+\**************************************/
+
+static void specialfn ( int key, int, int )
+{
+  puKeyboard ( key + PU_KEY_GLUT_SPECIAL_OFFSET, PU_DOWN ) ;
+  glutPostRedisplay () ;
+}
+
+static void keyfn ( unsigned char key, int, int )
+{
+  puKeyboard ( key, PU_DOWN ) ;
+  glutPostRedisplay () ;
+}
+
+static void motionfn ( int x, int y )
+{
+  puMouse ( x, y ) ;
+  glutPostRedisplay () ;
+}
+
+static void mousefn ( int button, int updown, int x, int y )
+{
+  puMouse ( button, updown, x, y ) ;
+  glutPostRedisplay () ;
+}
+
+/**************************************\
+*                                      *
+* This function redisplays the PUI and *
+* the tumbling cube, flips the double  *
+* buffer and then asks GLUT to post a  *
+* redisplay command - so we re-render  *
+* at maximum rate.                     *
+*                                      *
+\**************************************/
+
+static void displayfn (void)
+{
+  /* Clear the screen */
+
+  glClearColor ( 0.0, 0.0, 0.0, 1.0 ) ;
+  glClear      ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ;
+
+  /* Draw the tumbling cube */
+
+  float val ; rspeedSlider->getValue ( &val ) ;
+
+  glRotatef( 4*val, 15.0, 10.0 , 5.0 );
+
+  drawCube  () ;
+
+  /* Update the 'timer' */
+
+  time_t t = time ( NULL ) ;
+  timer_text -> setLabel ( ctime ( & t ) ) ;
+
+  /* Make PUI redraw */
+
+  puDisplay () ;
+  
+  /* Off we go again... */
+
+  glutSwapBuffers   () ;
+  glutPostRedisplay () ;
+}
+
+
+/***********************************\
+*                                   *
+* Here are the PUI widget callback  *
+* functions.                        *
+*                                   *
+\***********************************/
+
+void hide_menu_cb ( puObject *cb )
+{
+  if ( cb -> getValue () )
+  {
+    main_menu_bar -> reveal () ;
+    hide_menu_button->setLegend ( "Hide Menu" ) ;
+  }
+  else
+  {
+    main_menu_bar -> hide   () ;
+    hide_menu_button->setLegend ( "Show Menu" ) ;
+  }
+}
+
+
+void go_away_cb ( puObject * )
+{
+  /*
+    Delete the dialog box when its 'OK' button is pressed.
+
+    This seems to crash on MSVC compilers - probably because
+    I delete dialog_box - whose member function is calling
+    this function. Hence we return to something that is
+    in a distinctly 'iffy' state.
+  */
+
+  delete dialog_box ;
+  dialog_box = NULL ;
+}
+
+void mk_dialog ( char *txt )
+{
+  dialog_box = new puDialogBox ( 150, 50 ) ;
+  {
+    new puFrame ( 0, 0, 400, 100 ) ;
+    dialog_box_message   = new puText         ( 10, 70 ) ;
+    dialog_box_message   -> setLabel          ( txt ) ;
+    dialog_box_ok_button = new puOneShot      ( 180, 10, 240, 50 ) ;
+    dialog_box_ok_button -> setLegend         ( "OK" ) ;
+    dialog_box_ok_button -> makeReturnDefault ( TRUE ) ;
+    dialog_box_ok_button -> setCallback       ( go_away_cb ) ;
+  }
+  dialog_box -> close  () ;
+  dialog_box -> reveal () ;
+}
+
+void ni_cb ( puObject * )
+{
+  mk_dialog ( "Sorry, that function isn't implemented" ) ;
+}
+
+void about_cb ( puObject * )
+{
+  mk_dialog ( "This is the PUI 'complex' program" ) ;
+}
+
+void help_cb ( puObject * )
+{
+  mk_dialog ( "Sorry, no help is available for this demo" ) ;
+}
+
+void edit_cb ( puObject * )
+{
+}
+
+void exit_cb ( puObject * )
+{
+  fprintf ( stderr, "Exiting PUI demo program.\n" ) ;
+  exit ( 1 ) ;
+}
+
+/* Menu bar entries: */
+
+char      *file_submenu    [] = {  "Exit", "Close", "--------", "Print", "--------", "Save", "New", NULL } ;
+puCallback file_submenu_cb [] = { exit_cb, exit_cb,       NULL, ni_cb  ,       NULL,  ni_cb, ni_cb, NULL } ;
+
+char      *edit_submenu    [] = { "Edit text", NULL } ;
+puCallback edit_submenu_cb [] = {     edit_cb, NULL } ;
+
+char      *help_submenu    [] = { "About...",  "Help", NULL } ;
+puCallback help_submenu_cb [] = {   about_cb, help_cb, NULL } ;
+
+
+void sliderCB( puObject *sliderObj)
+{
+  glutPostRedisplay();
+}
+
+int main ( int argc, char **argv )
+{
+  firsttime = TRUE;
+
+#ifdef VOODOO
+  glutInitWindowPosition(   0,   0 ) ;
+#endif
+  glutInitWindowSize    ( 640, 480 ) ;
+  glutInit              ( &argc, argv ) ;
+  glutInitDisplayMode   ( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ) ;
+  glutCreateWindow      ( "Complex PUI Application"  ) ;
+  glutDisplayFunc       ( displayfn ) ;
+  glutKeyboardFunc      ( keyfn     ) ;
+  glutSpecialFunc       ( specialfn ) ;
+  glutMouseFunc         ( mousefn   ) ;
+  glutMotionFunc        ( motionfn  ) ;
+  glutPassiveMotionFunc ( motionfn  ) ;
+  glutIdleFunc          ( displayfn ) ;
+
+  puInit () ;
+
+#ifdef VOODOO
+  puShowCursor () ;
+#endif
+
+  puSetDefaultStyle        ( PUSTYLE_SMALL_SHADED ) ;
+  puSetDefaultColourScheme ( 0.8, 0.8, 0.8 ) ;
+
+  timer_text = new puText ( 300, 10 ) ;
+  timer_text -> setColour ( PUCOL_LABEL, 1.0, 1.0, 1.0 ) ;
+
+  /* Make a button to hide the menu bar */
+
+  hide_menu_button = new puButton     ( 10, 10, 150, 50 ) ;
+  hide_menu_button->setValue          (    TRUE      ) ;
+  hide_menu_button->setLegend         ( "Hide Menu"  ) ;
+  hide_menu_button->setCallback       ( hide_menu_cb ) ;
+  hide_menu_button->makeReturnDefault (    TRUE      ) ;
+
+  /* Make the menu bar */
+
+  main_menu_bar = new puMenuBar () ;
+  {
+    main_menu_bar -> add_submenu ( "File", file_submenu, file_submenu_cb ) ;
+    main_menu_bar -> add_submenu ( "Edit", edit_submenu, edit_submenu_cb ) ;
+    main_menu_bar -> add_submenu ( "Help", help_submenu, help_submenu_cb ) ;
+  }
+  main_menu_bar -> close () ; 
+
+  rspeedSlider = new puSlider (20,80,150,TRUE);
+  rspeedSlider->setDelta(0.1);
+  rspeedSlider->setCBMode( PUSLIDER_DELTA );
+  rspeedSlider->setCallback(sliderCB);
+
+  glutMainLoop () ;
+  return 0 ;
+}
+
+
@@ -0,0 +1,332 @@
+
+#include "puLocal.h"
+
+#ifdef PU_NOT_USING_GLUT
+#include <assert.h>
+#include <iostream.h>
+#endif
+
+#define PU_STRING_X_FUDGE 6
+#define PU_STRING_Y_FUDGE 6
+
+int puRefresh = TRUE ;
+
+#ifdef PU_NOT_USING_GLUT
+
+static int puWindowWidth  = 400 ;
+static int puWindowHeight = 400 ;
+
+int puGetWindowHeight () { return puWindowHeight ; }
+int puGetWindowWidth  () { return puWindowWidth  ; }
+
+void puSetWindowSize ( int width, int height )
+{
+  puWindowWidth  = width  ;
+  puWindowHeight = height ;
+}
+
+static int fontBase = 0;
+static int fontSize[257];
+#else
+
+int puGetWindowHeight () { return glutGet ( (GLenum) GLUT_WINDOW_HEIGHT ) ; }
+int puGetWindowWidth  () { return glutGet ( (GLenum) GLUT_WINDOW_WIDTH  ) ; }
+
+void puSetWindowSize ( int width, int height )
+{
+  fprintf ( stderr, "PUI: puSetWindowSize shouldn't be used with GLUT.\n" ) ;
+}
+
+#endif
+
+puColour _puDefaultColourTable[] =
+{
+  { 0.5f, 0.5f, 0.5f, 1.0f }, /* PUCOL_FOREGROUND */
+  { 0.3f, 0.3f, 0.3f, 1.0f }, /* PUCOL_BACKGROUND */
+  { 0.7f, 0.7f, 0.7f, 1.0f }, /* PUCOL_HIGHLIGHT  */
+  { 0.0f, 0.0f, 0.0f, 1.0f }, /* PUCOL_LABEL      */
+  { 1.0f, 1.0f, 1.0f, 1.0f }, /* PUCOL_TEXT       */
+
+  { 0.0f, 0.0f, 0.0f, 0.0f }  /* ILLEGAL */
+} ;
+ 
+
+puValue::~puValue () {}  
+
+static int _puCursor_enable = FALSE ;
+static int _puCursor_x      = 0 ;
+static int _puCursor_y      = 0 ;
+static float _puCursor_bgcolour [4] = { 1.0f, 1.0f, 1.0f, 1.0f } ; 
+static float _puCursor_fgcolour [4] = { 0.0f, 0.0f, 0.0f, 1.0f } ;  
+
+void   puHideCursor ( void ) { _puCursor_enable = FALSE ; }
+void   puShowCursor ( void ) { _puCursor_enable = TRUE  ; }
+int    puCursorIsHidden ( void ) { return ! _puCursor_enable ; }
+
+void puCursor ( int x, int y )
+{
+  _puCursor_x = x ;
+  _puCursor_y = y ;
+}
+
+int puGetStringDescender ( void *fnt )
+{
+  if ( fnt == NULL )
+    fnt = PUFONT_9_BY_15 ;
+
+  if ( fnt == PUFONT_8_BY_13        ) return 2 ;
+  if ( fnt == PUFONT_9_BY_15        ) return 3 ;
+  if ( fnt == PUFONT_TIMES_ROMAN_10 ) return 2 ;
+  if ( fnt == PUFONT_TIMES_ROMAN_24 ) return 5 ;
+  if ( fnt == PUFONT_HELVETICA_10   ) return 2 ;
+  if ( fnt == PUFONT_HELVETICA_12   ) return 3 ;
+  if ( fnt == PUFONT_HELVETICA_18   ) return 4 ;
+
+  return 0 ;
+}
+
+int puGetStringHeight ( void *fnt )
+{
+  /* Height *excluding* descender */
+  if ( fnt == NULL )
+    fnt = PUFONT_9_BY_15 ;
+
+  if ( fnt == PUFONT_8_BY_13        ) return  9 ;
+  if ( fnt == PUFONT_9_BY_15        ) return 10 ;
+  if ( fnt == PUFONT_TIMES_ROMAN_10 ) return  7 ;
+  if ( fnt == PUFONT_TIMES_ROMAN_24 ) return 17 ;
+  if ( fnt == PUFONT_HELVETICA_10   ) return  8 ;
+  if ( fnt == PUFONT_HELVETICA_12   ) return  9 ;
+  if ( fnt == PUFONT_HELVETICA_18   ) return 14 ;
+
+  return 0 ;
+}
+
+int puGetStringWidth ( void *fnt, char *str )
+{
+
+  if ( str == NULL )
+    return 0 ;
+
+  int res = 0 ;
+
+#ifdef PU_NOT_USING_GLUT
+  while ( *str != '\0' )
+  {
+    res += fontSize [ *str ] ;
+    str++ ;
+  }
+#else
+  if ( fnt == NULL )
+    fnt = PUFONT_9_BY_15 ;
+
+  while ( *str != '\0' )
+  {
+    res += glutBitmapWidth ( fnt, *str ) ;
+    str++ ;
+  }
+#endif
+
+  return res ;
+}
+
+
+void puDrawString ( void *fnt, char *str, int x, int y )
+{
+  if ( str == NULL )
+    return ;
+
+  glRasterPos2f((float)x, (float)y); 
+
+#ifdef PU_NOT_USING_GLUT
+  /*
+    Display a string: 
+       indicate start of glyph display lists 
+  */
+
+  glListBase (fontBase);
+
+  /* Now draw the characters in a string */
+
+  int len = strlen(str);
+  glCallLists(len, GL_UNSIGNED_BYTE, str); 
+  glListBase(0);
+#else
+  if ( fnt == NULL )
+    fnt = PUFONT_9_BY_15 ;
+
+  while ( *str != '\0' )
+  {
+    glutBitmapCharacter ( fnt, *str ) ;
+    str++ ;
+  }
+#endif
+}
+
+
+static void puDrawCursor ( int x, int y )
+{
+  glColor4fv ( _puCursor_bgcolour ) ;  
+
+  glBegin    ( GL_TRIANGLES ) ;
+  glVertex2i ( x, y ) ;
+  glVertex2i ( x + 13, y -  4 ) ;
+  glVertex2i ( x +  4, y - 13 ) ;
+
+  glVertex2i ( x +  8, y -  3 ) ;
+  glVertex2i ( x + 17, y - 12 ) ;
+  glVertex2i ( x + 12, y - 17 ) ;
+
+  glVertex2i ( x + 12, y - 17 ) ;
+  glVertex2i ( x +  3, y -  8 ) ;
+  glVertex2i ( x +  8, y -  3 ) ;
+  glEnd      () ;
+
+  glColor4fv ( _puCursor_fgcolour ) ;  
+
+  glBegin    ( GL_TRIANGLES ) ;
+  glVertex2i ( x+1, y-1 ) ;
+  glVertex2i ( x + 11, y -  4 ) ;
+  glVertex2i ( x +  4, y - 11 ) ;
+
+  glVertex2i ( x +  8, y -  5 ) ;
+  glVertex2i ( x + 15, y - 12 ) ;
+  glVertex2i ( x + 12, y - 15 ) ;
+
+  glVertex2i ( x + 12, y - 15 ) ;
+  glVertex2i ( x +  5, y -  8 ) ;
+  glVertex2i ( x +  8, y -  5 ) ;
+  glEnd      () ;
+}
+
+void  puInit ( void )
+{
+  static int firsttime = TRUE ;
+
+  if ( firsttime )
+  {
+    puInterface *base_interface = new puInterface ( 0, 0 ) ;
+    puPushInterface     ( base_interface ) ;
+    puPushLiveInterface ( base_interface ) ;
+    firsttime = FALSE ;
+#ifdef PU_NOT_USING_GLUT
+
+    /* Create bitmaps for the device context font's first 256 glyphs */
+
+    fontBase = glGenLists(256);
+    assert(fontBase);
+    HDC hdc = wglGetCurrentDC();
+
+    /* Make the system font the device context's selected font */
+
+    SelectObject (hdc, GetStockObject (SYSTEM_FONT)); 
+
+    int *tempSize = &fontSize[1];
+
+    if ( ! GetCharWidth32 ( hdc, 1, 255, tempSize ) &&
+         ! GetCharWidth   ( hdc, 1, 255, tempSize ) )
+    {
+      LPVOID lpMsgBuf ;
+
+      FormatMessage ( FORMAT_MESSAGE_ALLOCATE_BUFFER |
+	              FORMAT_MESSAGE_FROM_SYSTEM,
+	              NULL,
+	              GetLastError(),
+	              MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+	              (LPTSTR) &lpMsgBuf,
+	              0, NULL ) ;
+
+      fprintf ( stderr, "PUI: Error: %s\n", (char *)lpMsgBuf ) ;
+      LocalFree ( lpMsgBuf ) ;
+    }
+
+    wglUseFontBitmaps ( hdc, 0, 256, fontBase ) ;
+#endif
+  }
+}
+
+static void puSetOpenGLState ( void )
+{
+  int w = puGetWindowWidth  () ;
+  int h = puGetWindowHeight () ;
+
+  glPushAttrib   ( GL_ENABLE_BIT | GL_VIEWPORT_BIT | GL_TRANSFORM_BIT ) ;
+  glDisable      ( GL_LIGHTING   ) ;
+  glDisable      ( GL_FOG        ) ;
+  glDisable      ( GL_TEXTURE_2D ) ;
+  glDisable      ( GL_DEPTH_TEST ) ;
+  glDisable      ( GL_CULL_FACE  ) ;
+ 
+  glViewport     ( 0, 0, w, h ) ;
+  glMatrixMode   ( GL_PROJECTION ) ;
+  glPushMatrix   () ;
+  glLoadIdentity () ;
+  gluOrtho2D     ( 0, w, 0, h ) ;
+  glMatrixMode   ( GL_MODELVIEW ) ;
+  glPushMatrix   () ;
+  glLoadIdentity () ;
+}
+
+static void puRestoreOpenGLState ( void )
+{
+  glMatrixMode   ( GL_PROJECTION ) ;
+  glPopMatrix    () ;
+  glMatrixMode   ( GL_MODELVIEW ) ;
+  glPopMatrix    () ;
+  glPopAttrib    () ;
+}
+
+
+void  puDisplay ( void )
+{
+  puSetOpenGLState () ;
+  puGetUltimateLiveInterface () -> draw ( 0, 0 ) ;
+
+  int h = puGetWindowHeight () ;
+
+  if ( _puCursor_enable )
+    puDrawCursor ( _puCursor_x,
+                   h - _puCursor_y ) ;
+
+  puRestoreOpenGLState () ;
+}
+
+int puKeyboard ( int key, int updown )
+{
+  return puGetBaseLiveInterface () -> checkKey ( key, updown ) ;
+}
+
+
+static int last_buttons = 0 ;
+int puMouse ( int button, int updown, int x, int y )
+{
+  puCursor ( x, y ) ;
+
+  int h = puGetWindowHeight () ;
+
+  if ( updown == PU_DOWN )
+    last_buttons |=  ( 1 << button ) ;
+  else
+    last_buttons &= ~( 1 << button ) ;
+
+  return puGetBaseLiveInterface () -> checkHit ( button, updown, x,
+                                 h - y ) ;
+}
+
+int puMouse ( int x, int y )
+{
+  puCursor ( x, y ) ;
+
+  if ( last_buttons == 0 )
+    return FALSE ;
+
+  int button = (last_buttons & (1<<PU_LEFT_BUTTON  )) ?  PU_LEFT_BUTTON   :
+               (last_buttons & (1<<PU_MIDDLE_BUTTON)) ?  PU_MIDDLE_BUTTON :
+               (last_buttons & (1<<PU_RIGHT_BUTTON )) ?  PU_RIGHT_BUTTON  : 0 ;
+
+  int h = puGetWindowHeight () ;
+
+  return puGetBaseLiveInterface () -> checkHit ( button, PU_DRAG, x,
+                                 h - y ) ;
+}
+
@@ -0,0 +1,805 @@
+#ifndef _PU_H_
+#define _PU_H_
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef PU_NOT_USING_GLUT
+#include <windows.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#else
+#include <GL/glut.h>
+#endif
+
+#ifndef TRUE
+#define TRUE  1
+#define FALSE 0
+#endif
+
+/*
+  Webster's Dictionary (for American English) permits
+  Color or Colour as acceptable spellings - but
+  The Oxford English Dictionary (for English) only
+  permits Colour.
+
+  Hence, the logical thing to do is to use 'colour',
+  which *ought* to be acceptable on both sides of
+  the atlantic.
+
+  However, as a concession to the illogical:
+*/
+
+#define setColorScheme          setColourScheme
+#define setColor                setColour
+#define getColor                getColour
+#define puColor                 puColour
+#define puSetColor              puSetColour
+#define puSetDefaultColorScheme puSetDefaultColourScheme
+#define puGetDefaultColorScheme puGetDefaultColourScheme
+
+
+typedef void *puFont ;
+
+#ifdef PU_NOT_USING_GLUT
+#define PU_LEFT_BUTTON		0
+#define PU_LEFT_BUTTON		0
+#define PU_MIDDLE_BUTTON	1
+#define PU_RIGHT_BUTTON		2
+#define PU_DOWN			0
+#define PU_UP		        1
+
+#define PUFONT_8_BY_13        ((void*)3)
+#define PUFONT_9_BY_15        ((void*)2)
+#define PUFONT_TIMES_ROMAN_10 ((void*)4)
+#define PUFONT_TIMES_ROMAN_24 ((void*)5)
+#define PUFONT_HELVETICA_10   ((void*)6)
+#define PUFONT_HELVETICA_12   ((void*)7)
+#define PUFONT_HELVETICA_18   ((void*)8)
+
+#else
+
+#define PUFONT_8_BY_13        GLUT_BITMAP_8_BY_13
+#define PUFONT_9_BY_15        GLUT_BITMAP_9_BY_15
+#define PUFONT_TIMES_ROMAN_10 GLUT_BITMAP_TIMES_ROMAN_10
+#define PUFONT_TIMES_ROMAN_24 GLUT_BITMAP_TIMES_ROMAN_24
+#define PUFONT_HELVETICA_10   GLUT_BITMAP_HELVETICA_10
+#define PUFONT_HELVETICA_12   GLUT_BITMAP_HELVETICA_12
+#define PUFONT_HELVETICA_18   GLUT_BITMAP_HELVETICA_18
+
+#define PU_LEFT_BUTTON      GLUT_LEFT_BUTTON
+#define PU_MIDDLE_BUTTON    GLUT_MIDDLE_BUTTON
+#define PU_RIGHT_BUTTON     GLUT_RIGHT_BUTTON
+#define PU_DOWN             GLUT_DOWN
+#define PU_UP               GLUT_UP
+#endif	// PU_NOT_USING_GLUT
+
+#define PU_UP_AND_DOWN   254
+#define PU_DRAG          255
+#define PU_CONTINUAL     PU_DRAG
+
+#define PU_KEY_GLUT_SPECIAL_OFFSET  256
+
+#ifdef PU_NOT_USING_GLUT
+#define PU_KEY_F1        (1		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F2        (2		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F3        (3		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F4        (4	    + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F5        (5		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F6        (6		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F7        (7		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F8        (8		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F9        (9		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F10       (10		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F11       (11		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F12       (12		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_LEFT      (100		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_UP        (101		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_RIGHT     (102		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_DOWN      (103		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_PAGE_UP   (104		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_PAGE_DOWN (105		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_HOME      (106		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_END       (107		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_INSERT    (108		+ PU_KEY_GLUT_SPECIAL_OFFSET)
+
+#else
+#define PU_KEY_F1        (GLUT_KEY_F1        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F2        (GLUT_KEY_F2        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F3        (GLUT_KEY_F3        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F4        (GLUT_KEY_F4        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F5        (GLUT_KEY_F5        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F6        (GLUT_KEY_F6        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F7        (GLUT_KEY_F7        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F8        (GLUT_KEY_F8        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F9        (GLUT_KEY_F9        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F10       (GLUT_KEY_F10       + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F11       (GLUT_KEY_F11       + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_F12       (GLUT_KEY_F12       + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_LEFT      (GLUT_KEY_LEFT      + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_UP        (GLUT_KEY_UP        + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_RIGHT     (GLUT_KEY_RIGHT     + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_DOWN      (GLUT_KEY_DOWN      + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_PAGE_UP   (GLUT_KEY_PAGE_UP   + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_PAGE_DOWN (GLUT_KEY_PAGE_DOWN + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_HOME      (GLUT_KEY_HOME      + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_END       (GLUT_KEY_END       + PU_KEY_GLUT_SPECIAL_OFFSET)
+#define PU_KEY_INSERT    (GLUT_KEY_INSERT    + PU_KEY_GLUT_SPECIAL_OFFSET)
+#endif	// PU_NOT_USING_GLUT
+
+#define PUPLACE_DEFAULT  PUPLACE_RIGHT
+#define PUPLACE_ABOVE    0
+#define PUPLACE_BELOW    1
+#define PUPLACE_LEFT     2
+#define PUPLACE_RIGHT    3
+
+#define PUCOL_FOREGROUND 0
+#define PUCOL_BACKGROUND 1
+#define PUCOL_HIGHLIGHT  2
+#define PUCOL_LABEL      3
+#define PUCOL_LEGEND     4
+#define PUCOL_MAX        5
+
+#define PUSLIDER_CLICK   0
+#define PUSLIDER_ALWAYS  1
+#define PUSLIDER_DELTA   2
+
+/* These styles may be negated to get 'highlighted' graphics */
+
+#define PUSTYLE_DEFAULT    PUSTYLE_SHADED
+#define PUSTYLE_NONE       0
+#define PUSTYLE_PLAIN      1
+#define PUSTYLE_BEVELLED   2
+#define PUSTYLE_BOXED      3
+#define PUSTYLE_DROPSHADOW 4
+#define PUSTYLE_SPECIAL_UNDERLINED 5
+#define PUSTYLE_SMALL_BEVELLED     6
+#define PUSTYLE_RADIO      7
+#define PUSTYLE_SHADED     8
+#define PUSTYLE_SMALL_SHADED   9
+#define PUSTYLE_MAX        10
+
+/* These are the gaps that we try to leave around text objects */
+
+#define PUSTR_TGAP   5
+#define PUSTR_BGAP   5
+#define PUSTR_LGAP   5
+#define PUSTR_RGAP   5
+#define PUSTR_MAX_HEIGHT  ( 25 + PUSTR_TGAP + PUSTR_BGAP )
+
+#define PU_RADIO_BUTTON_SIZE 16
+
+extern int puRefresh ;
+
+#define PUCLASS_VALUE            0x00000001
+#define PUCLASS_OBJECT           0x00000002
+#define PUCLASS_INTERFACE        0x00000004
+#define PUCLASS_FRAME            0x00000008
+#define PUCLASS_TEXT             0x00000010
+#define PUCLASS_BUTTON           0x00000020
+#define PUCLASS_ONESHOT          0x00000040
+#define PUCLASS_POPUP            0x00000080
+#define PUCLASS_POPUPMENU        0x00000100
+#define PUCLASS_MENUBAR          0x00000200
+#define PUCLASS_INPUT            0x00000400
+#define PUCLASS_BUTTONBOX        0x00000800
+#define PUCLASS_SLIDER           0x00001000
+#define PUCLASS_DIALOGBOX        0x00002000
+
+/* This function is not required for GLUT programs */
+void puSetWindowSize ( int width, int height ) ;
+
+int  puGetWindowHeight () ;
+int  puGetWindowWidth  () ;
+
+class puValue            ;
+class puObject           ;
+class puInterface        ;
+class puButtonBox        ;
+class puFrame            ;
+class puText             ;
+class puButton           ;
+class puOneShot          ;
+class puPopup            ;
+class puPopupMenu        ;
+class puMenuBar          ;
+class puInput            ;
+class puSlider           ;
+
+typedef float puColour [ 4 ] ;  /* RGBA */
+
+struct puBox
+{
+  int min [ 2 ] ;
+  int max [ 2 ] ;
+
+  void draw   ( int dx, int dy, int style, puColour colour[], int am_default ) ;
+  void extend ( puBox *bx ) ;
+
+  void empty   ( void ) { min[0]=min[1]=1000000 ; max[0]=max[1]=-1000000 ; }
+  int  isEmpty ( void ) { return min[0]>max[0] || min[1]>max[1] ; }
+} ;
+
+#define PUSTRING_MAX 80
+
+/* If you change - or add to these, be sure to change _puDefaultColourTable */
+
+extern puColour _puDefaultColourTable[] ;
+
+
+inline void puSetColour ( puColour dst, puColour src )
+{
+  dst[0] = src[0] ; dst[1] = src[1] ; dst[2] = src[2] ; dst[3] = src[3] ;
+}
+
+inline void puSetColour ( puColour c, float r, float g, float b, float a = 1.0f )
+{
+  c [ 0 ] = r ; c [ 1 ] = g ; c [ 2 ] = b ; c [ 3 ] = a ;
+}
+
+
+void  puInit           ( void ) ;
+void  puDisplay        ( void ) ;
+int   puMouse          ( int button, int updown, int x, int y ) ;
+int   puMouse          ( int x, int y ) ;
+int   puKeyboard       ( int key, int updown ) ;
+void  puHideCursor     ( void ) ;
+void  puShowCursor     ( void ) ;
+int   puCursorIsHidden ( void ) ;
+
+void puDrawString         ( puFont fnt, char *str, int x, int y ) ;
+int  puGetStringWidth     ( puFont fnt, char *str ) ;
+int  puGetStringHeight    ( puFont fnt = NULL ) ;
+int  puGetStringDescender ( puFont fnt = NULL ) ;
+
+class puValue
+{
+protected:
+  int   type    ;
+  int   integer ;
+  float floater ;
+  char  string  [ PUSTRING_MAX ] ;
+public:
+  puValue () { type = PUCLASS_VALUE ; clrValue () ; }
+
+  virtual ~puValue () ;
+
+  int  getType ( void ) { return type ; }
+  char *getTypeString ( void ) ;
+  void clrValue ( void ) { setValue ( "" ) ; }
+
+  void setValue ( puValue *pv )
+  {
+    integer = pv -> integer ;
+    floater = pv -> floater ;
+    strcpy ( string, pv -> string ) ;
+    puRefresh = TRUE ;
+  }
+
+  void setValue ( int   i ) { integer = i ; floater = (float) i ; sprintf ( string, "%d", i ) ; puRefresh = TRUE ; }
+  void setValue ( float f ) { integer = (int) f ; floater = f ; sprintf ( string, "%g", f ) ; puRefresh = TRUE ; }
+  void setValue ( char *s ) { 
+                              if ( s == NULL || s[0] == '\0' )
+                              {
+                                integer = 0 ;
+                                floater = 0.0f ;
+                                s = "" ;
+                              }
+                              else
+                              {
+                                integer = atoi(s) ;
+                                floater = (float)atof(s) ;
+
+                                if ( string != s ) strcpy ( string, s ) ;
+                              }
+                              puRefresh = TRUE ;
+                            }
+
+  void getValue ( int   *i ) { *i = integer ; }
+  void getValue ( float *f ) { *f = floater ; }
+  void getValue ( char **s ) { *s = string  ; }
+  void getValue ( char  *s ) { strcpy ( s, string ) ; }
+
+  int  getValue ( void ) { return integer ; }
+} ;
+
+typedef void (*puCallback)(class puObject *) ;
+
+void puSetDefaultStyle ( int  style ) ;
+int  puGetDefaultStyle ( void ) ;
+void puSetDefaultFonts ( puFont  legendFont, puFont  labelFont ) ;
+void puGetDefaultFonts ( puFont *legendFont, puFont *labelFont ) ;
+void puSetDefaultColourScheme ( float r, float g, float b, float a = 1.0 ) ;
+void puGetDefaultColourScheme ( float *r, float *g, float *b, float *a = NULL );
+
+class puObject : public puValue
+{
+protected:
+  puValue default_value ;
+
+  puBox bbox ;   /* Bounding box of entire Object */
+  puBox abox ;   /* Active (clickable) area */
+  puColour colour [ PUCOL_MAX ] ;
+  puInterface *parent ;
+
+  int active_mouse_edge ; /* is it PU_UP or PU_DOWN (or both) that activates this? */
+  int style       ;
+  int visible     ;
+  int active      ;
+  int highlighted ;
+  int am_default  ;
+
+  char *label  ; puFont  labelFont ; int labelPlace ;
+  char *legend ; puFont legendFont ;
+
+  void *user_data ;
+  puCallback cb ;
+
+  virtual void draw_label  ( int dx, int dy ) ;
+  virtual int  isHit ( int x, int y ) { return isVisible() && isActive() &&
+                                               x >= abox.min[0] &&
+                                               x <= abox.max[0] &&
+                                               y >= abox.min[1] &&
+                                               y <= abox.max[1] ; }
+  virtual void doHit ( int button, int updown, int x, int y ) ;
+
+public:
+   puObject ( int minx, int miny, int maxx, int maxy ) ;
+  ~puObject () ;
+
+  puObject *next ;
+  puObject *prev ;
+ 
+  puBox *getBBox ( void ) { return & bbox ; }
+  puBox *getABox ( void ) { return & abox ; }
+
+  void setPosition ( int x, int y )
+  {
+    if ( abox.isEmpty() )
+    {
+      abox.max[0] = abox.min[0] = x ;
+      abox.max[1] = abox.min[1] = y ;
+    }
+    else
+    {
+      abox.max[0] += x - abox.min[0] ;
+      abox.max[1] += y - abox.min[1] ;
+      abox.min[0]  = x ;
+      abox.min[1]  = y ;
+    }
+    recalc_bbox() ; puRefresh = TRUE ;
+  }
+
+  void setSize ( int w, int h )
+  {
+    abox.max[0] = abox.min[0] + w ;
+    abox.max[1] = abox.min[1] + h ;
+    recalc_bbox() ; puRefresh = TRUE ;
+  }
+
+  void getPosition ( int *x, int *y )
+  {
+    if ( abox . isEmpty () )
+    {
+      if ( x ) *x = 0 ;
+      if ( y ) *y = 0 ;
+    }
+    else
+    {
+      if ( x ) *x = abox.min[0] ;
+      if ( y ) *y = abox.min[1] ;
+    }
+  }
+
+  void getSize ( int *w, int *h )
+  {
+    if ( abox . isEmpty () )
+    {
+      if ( w ) *w = 0 ;
+      if ( h ) *h = 0 ;
+    }
+    else
+    {
+      if ( w ) *w = abox.max[0] - abox.min[0] ;
+      if ( h ) *h = abox.max[1] - abox.min[1] ;
+    }
+  }
+
+  virtual void recalc_bbox ( void ) ;
+  virtual int  checkHit ( int button, int updown, int x, int y ) ;
+  virtual int  checkKey ( int key   , int updown ) ;
+  virtual void draw ( int dx, int dy ) = 0 ;
+
+  puInterface *getParent     ( void ) { return parent ; }
+  puObject    *getNextObject ( void ) { return next   ; }
+  puObject    *getPrevObject ( void ) { return prev   ; }
+
+  void       setCallback ( puCallback c ) { cb = c ;    }
+  puCallback getCallback ( void )               { return cb ; }
+  void       invokeCallback ( void ) { if ( cb ) (*cb)(this) ; }
+
+  void  makeReturnDefault ( int def ) { am_default = def ; }
+  int   isReturnDefault   ( void )          { return am_default ; }
+
+  void  setActiveDirn ( int e ) { active_mouse_edge = e ; }
+  int   getActiveDirn ( void ) { return active_mouse_edge ; }
+
+  void  setLegend ( char *l ) { legend = l ; recalc_bbox() ; puRefresh = TRUE ; }
+  char *getLegend ( void ) { return legend ; }
+
+  void  setLegendFont ( puFont f ) { legendFont = f ; recalc_bbox() ; puRefresh = TRUE ; }
+  puFont getLegendFont ( void ) { return legendFont ; }
+
+  void  setLabel ( char *l ) { label = l ; recalc_bbox() ; puRefresh = TRUE ; }
+  char *getLabel ( void ) { return label ; }
+
+  void  setLabelFont ( puFont f ) { labelFont = f ; recalc_bbox() ; puRefresh = TRUE ; }
+  puFont getLabelFont ( void ) { return labelFont ; }
+
+  void  setLabelPlace ( int lp ) { labelPlace = lp ; recalc_bbox() ; puRefresh = TRUE ; }
+  int   getLabelPlace ( void ) { return labelPlace ; }
+
+  void activate   ( void ) { if ( ! active  ) { active  = TRUE  ; puRefresh = TRUE ; } }
+  void greyOut    ( void ) { if (   active  ) { active  = FALSE ; puRefresh = TRUE ; } }
+  int  isActive   ( void ) { return active ; }
+
+  void highlight  ( void ) { if ( ! highlighted ) { highlighted = TRUE  ; puRefresh = TRUE ; } }
+  void lowlight   ( void ) { if (   highlighted ) { highlighted = FALSE ; puRefresh = TRUE ; } }
+  int isHighlighted( void ){ return highlighted ; }
+
+  void reveal     ( void ) { if ( ! visible ) { visible = TRUE  ; puRefresh = TRUE ; } }
+  void hide       ( void ) { if (   visible ) { visible = FALSE ; puRefresh = TRUE ; } }
+  int  isVisible  ( void ) { return visible ; }
+
+  void setStyle ( int which )
+  {
+    style = which ;
+    recalc_bbox () ;
+    puRefresh = TRUE ;
+  }
+
+  int  getStyle ( void ) { return style ; }
+
+  void setColourScheme ( float r, float g, float b, float a = 1.0f ) ;
+
+  void setColour ( int which, float r, float g, float b, float a = 1.0f )
+  {
+    puSetColour ( colour [ which ], r, g, b, a ) ;
+    puRefresh = TRUE ;
+  }
+
+  void getColour ( int which, float *r, float *g, float *b, float *a = NULL )
+  {
+    if ( r ) *r = colour[which][0] ;
+    if ( g ) *g = colour[which][1] ;
+    if ( b ) *b = colour[which][2] ;
+    if ( a ) *a = colour[which][3] ;
+  }
+
+  void  setUserData ( void *data ) { user_data = data ; }
+  void *getUserData ( void )             { return user_data ; }
+
+  void defaultValue ( void ) { setValue ( & default_value ) ; }
+
+  void setDefaultValue ( int    i ) { default_value . setValue ( i ) ; }
+  void setDefaultValue ( float  f ) { default_value . setValue ( f ) ; }
+  void setDefaultValue ( char  *s ) { default_value . setValue ( s ) ; }
+
+  void getDefaultValue ( int   *i ) { default_value . getValue ( i ) ; }
+  void getDefaultValue ( float *f ) { default_value . getValue ( f ) ; }
+  void getDefaultValue ( char **s ) { default_value . getValue ( s ) ; }
+  int  getDefaultValue ( void )    { return default_value . getValue () ; }
+} ;
+
+/*
+  The 'live' interface stack is used for clicking and rendering.
+*/
+
+void         puPushLiveInterface        ( puInterface *in ) ;
+void         puPopLiveInterface         ( void ) ;
+int          puNoLiveInterface          ( void ) ;
+puInterface *puGetBaseLiveInterface     ( void ) ;
+puInterface *puGetUltimateLiveInterface ( void ) ;
+
+/*
+  The regular interface stack is used for adding widgets
+*/
+
+void         puPushInterface        ( puInterface *in ) ;
+void         puPopInterface         ( void ) ;
+int          puNoInterface          ( void ) ;
+puInterface *puGetCurrInterface     ( void ) ;
+
+class puInterface : public puObject
+{
+protected:
+  int num_children ;
+  puObject *dlist ;
+
+  void doHit       ( int button, int updown, int x, int y ) ;
+
+public:
+
+  puInterface ( int x, int y ) : puObject ( x, y, x, y )
+  {
+    type |= PUCLASS_INTERFACE ;
+    dlist = NULL ;
+    num_children = 0 ;
+    puPushInterface ( this ) ;
+    puPushLiveInterface ( this ) ;
+  }
+
+  ~puInterface () ;
+
+  void recalc_bbox ( void ) ;
+  virtual void add    ( puObject *new_object ) ;
+  virtual void remove ( puObject *old_object ) ;
+
+  void draw        ( int dx, int dy ) ;
+  int  checkHit    ( int button, int updown, int x, int y ) ;
+  int  checkKey    ( int key   , int updown ) ;
+
+  puObject *getFirstChild ( void ) { return dlist ; }
+  int getNumChildren ( void ) { return num_children ; }
+
+  virtual void close ( void )
+  {
+    if ( puGetCurrInterface () != this )
+      fprintf ( stderr, "PUI: puInterface::close() is mismatched!\n" ) ;
+    else
+      puPopInterface () ;
+  }
+} ;
+
+class puFrame : public puObject
+{
+protected:
+  virtual int  isHit ( int /* x */, int /* y */ ) { return FALSE ; }
+public:
+  void draw ( int dx, int dy ) ;
+  puFrame ( int minx, int miny, int maxx, int maxy ) :
+             puObject ( minx, miny, maxx, maxy )
+  {
+    type |= PUCLASS_FRAME ;
+  }
+} ;
+
+
+class puText : public puObject
+{
+protected:
+  virtual int  isHit ( int /* x */, int /* y */ ) { return FALSE ; }
+public:
+  void draw ( int dx, int dy ) ;
+  puText ( int x, int y ) : puObject ( x, y, x, y )
+  {
+    type |= PUCLASS_TEXT ;
+  }
+} ;
+
+
+class puButton : public puObject
+{
+protected:
+public:
+  void doHit ( int button, int updown, int x, int y ) ;
+  void draw  ( int dx, int dy ) ;
+  puButton   ( int minx, int miny, char *l ) :
+                 puObject ( minx, miny,
+                            minx + puGetStringWidth  ( NULL, l ) + PUSTR_LGAP + PUSTR_RGAP,
+                            miny + puGetStringHeight () + puGetStringDescender () + PUSTR_TGAP + PUSTR_BGAP )
+  {
+    type |= PUCLASS_BUTTON ;
+    setLegend ( l ) ;
+  }
+
+  puButton   ( int minx, int miny, int maxx, int maxy ) :
+                 puObject ( minx, miny, maxx, maxy )
+  {
+    type |= PUCLASS_BUTTON ;
+  }
+} ;
+
+
+class puSlider : public puObject
+{
+protected:
+  int vert ;
+  float last_cb_value ;
+  float cb_delta ;
+  int   cb_mode ;
+  float slider_fraction ;
+public:
+  void doHit ( int button, int updown, int x, int y ) ;
+  void draw  ( int dx, int dy ) ;
+  puSlider ( int minx, int miny, int sz, int vertical = FALSE ) :
+     puObject ( minx, miny, vertical ?
+                             ( minx + puGetStringWidth ( NULL, "W" ) +
+                                      PUSTR_LGAP + PUSTR_RGAP ) :
+                             ( minx + sz ),
+                            vertical ?
+                             ( miny + sz ) :
+                             ( miny + puGetStringHeight () +
+                                      puGetStringDescender () +
+                                      PUSTR_TGAP + PUSTR_BGAP )
+                           )
+  {
+    type |= PUCLASS_SLIDER ;
+    slider_fraction = 0.1f ;
+    getValue ( & last_cb_value ) ;
+    vert = vertical ;
+    cb_delta = 0.1f ;
+    cb_mode = PUSLIDER_ALWAYS ;
+  }
+
+  void setCBMode ( int m ) { cb_mode = m ; }
+  float getCBMode ( void ) { return (float)cb_mode ; }
+
+  int  isVertical ( void ) { return vert ; }
+
+  void setDelta ( float f ) { cb_delta = (f<=0.0f) ? 0.1f : (f>=1.0f) ? 0.9f : f ; }
+  float getDelta ( void ) { return cb_delta ; }
+
+  void setSliderFraction ( float f ) { slider_fraction = (f<=0.0f) ? 0.1f : (f>=1.0f) ? 0.9f : f ; }
+  float getSliderFraction ( void ) { return slider_fraction ; }
+} ;
+
+
+
+class puOneShot : public puButton
+{
+protected:
+public:
+  void doHit ( int button, int updown, int x, int y ) ;
+
+  puOneShot ( int minx, int miny, char *l ) : puButton   ( minx, miny, l )
+  {
+    type |= PUCLASS_ONESHOT ;
+  }
+
+  puOneShot ( int minx, int miny, int maxx, int maxy ) :
+                 puButton ( minx, miny, maxx, maxy )
+  {
+    type |= PUCLASS_ONESHOT ;
+  }
+} ;
+
+
+
+class puPopup : public puInterface
+{
+protected:
+public:
+  puPopup ( int x, int y ) : puInterface ( x, y )
+  {
+    type |= PUCLASS_POPUP ;
+    hide () ;
+  }
+} ;
+
+class puPopupMenu : public puPopup
+{
+protected:
+public:
+  puPopupMenu ( int x, int y ) : puPopup ( x, y )
+  {
+    type |= PUCLASS_POPUPMENU ;
+  }
+
+  puObject *add_item ( char *str, puCallback cb ) ;
+  int  checkHit ( int button, int updown, int x, int y ) ;
+  int  checkKey ( int key   , int updown ) ;
+  void close ( void ) ;
+} ;
+
+class puMenuBar : public puInterface
+{
+protected:
+public:
+  puMenuBar ( int h = -1 ) :
+
+  puInterface ( 0, h < 0 ? puGetWindowHeight() -
+                      ( puGetStringHeight() + PUSTR_TGAP + PUSTR_BGAP ) : h )
+  {
+    type |= PUCLASS_MENUBAR ;
+  }
+
+  void add_submenu ( char *str, char *items[], puCallback cb[] ) ;
+  void close ( void ) ;
+} ;
+
+
+class puInput : public puObject
+{
+  int accepting ;
+  int cursor_position ;
+  int select_start_position ;
+  int select_end_position ;
+
+  void normalize_cursors ( void ) ;
+
+public:
+  void draw     ( int dx, int dy ) ;
+  void doHit    ( int button, int updown, int x, int y ) ;
+  int  checkKey ( int key, int updown ) ;
+
+  int  isAcceptingInput ( void ) { return accepting ; }
+  void rejectInput      ( void ) { accepting = FALSE ; }
+  void acceptInput      ( void ) { accepting = TRUE ;
+                             cursor_position = strlen ( string ) ;
+                             select_start_position = select_end_position = -1 ; }
+
+  int  getCursor ( void )        { return cursor_position ; }
+  void setCursor ( int c ) { cursor_position = c ; }
+
+  void setSelectRegion ( int s, int e )
+  {
+    select_start_position = s ;
+    select_end_position   = e ;
+  }
+
+  void getSelectRegion ( int *s, int *e )
+  {
+    if ( s ) *s = select_start_position ;
+    if ( e ) *e = select_end_position   ;
+  }
+
+  puInput ( int minx, int miny, int maxx, int maxy ) :
+             puObject ( minx, miny, maxx, maxy )
+  {
+    type |= PUCLASS_INPUT ;
+
+    accepting = FALSE ;
+
+    cursor_position       =  0 ;
+    select_start_position = -1 ;
+    select_end_position   = -1 ;
+
+    setColourScheme ( 0.8f, 0.7f, 0.7f ) ; /* Yeukky Pink */
+  }
+} ;
+
+
+class puButtonBox : public puObject
+{
+protected:
+  int one_only ;
+  int num_kids ;
+  char **button_labels ;
+
+public:
+
+  puButtonBox ( int minx, int miny, int maxx, int maxy, 
+                char **labels, int one_button ) ;
+
+  int isOneButton ( void ) { return one_only ; }
+
+  int checkKey ( int key   , int updown ) ;
+  int checkHit ( int button, int updown, int x, int y ) ;
+  void draw    ( int dx, int dy ) ;
+} ;
+
+
+
+class puDialogBox : public puPopup
+{
+protected:
+public:
+
+  puDialogBox ( int x, int y ) : puPopup ( x, y )
+  {
+    type |= PUCLASS_DIALOGBOX ;
+  }
+} ;
+
+#endif
+
@@ -0,0 +1,319 @@
+
+#include "puLocal.h"
+
+#define PU_BEVEL              5
+#define PU_SMALL_BEVEL        2
+#define PU_DFLT_OFFSET        8
+#define PU_BOX_WIDTH          2
+#define PU_DROPSHADOW_OFFSET  5
+
+void puBox::extend ( puBox *bx )
+{
+  if ( bx -> isEmpty () ) return ;
+
+  if ( min[0]>bx->min[0] ) min[0] = bx->min[0] ;
+  if ( min[1]>bx->min[1] ) min[1] = bx->min[1] ;
+  if ( max[0]<bx->max[0] ) max[0] = bx->max[0] ;
+  if ( max[1]<bx->max[1] ) max[1] = bx->max[1] ;
+}
+ 
+
+ 
+void puBox::draw ( int dx, int dy, int style, puColour colour[], int am_default  )
+{
+  int hi, mid, lo ;
+
+  /* Colour assignments */
+
+  switch ( style )
+  {
+    case  PUSTYLE_NONE       :
+      return ;
+
+    case  PUSTYLE_PLAIN      :
+    case  PUSTYLE_DROPSHADOW :
+      mid = PUCOL_FOREGROUND ;
+      lo  = PUCOL_BACKGROUND ;
+      break ;
+
+    case  PUSTYLE_SMALL_SHADED :
+    case  PUSTYLE_SHADED     :
+    case  PUSTYLE_SMALL_BEVELLED :
+    case  PUSTYLE_BEVELLED   :
+    case  PUSTYLE_BOXED      :
+    case  PUSTYLE_SPECIAL_UNDERLINED :
+      mid = PUCOL_FOREGROUND ;
+      hi  = PUCOL_HIGHLIGHT  ;
+      lo  = PUCOL_BACKGROUND ;
+      break ;
+
+    case  PUSTYLE_RADIO      :
+    case -PUSTYLE_RADIO      :
+      hi  = PUCOL_HIGHLIGHT  ;
+      lo  = PUCOL_BACKGROUND ;
+      break ;
+
+    case -PUSTYLE_PLAIN      :
+    case -PUSTYLE_DROPSHADOW :
+      mid = PUCOL_HIGHLIGHT  ;
+      lo  = PUCOL_BACKGROUND ;
+      break ;
+
+    case -PUSTYLE_SMALL_BEVELLED :
+    case -PUSTYLE_BEVELLED   :
+    case -PUSTYLE_SMALL_SHADED :
+    case -PUSTYLE_SHADED     :
+    case -PUSTYLE_BOXED      :
+    case -PUSTYLE_SPECIAL_UNDERLINED :
+      mid = PUCOL_FOREGROUND ;
+      hi  = PUCOL_BACKGROUND ;
+      lo  = PUCOL_HIGHLIGHT  ;
+      break ;
+
+    default :
+      fprintf ( stderr, "PUI: Unrecognised 'style' %d\n", style ) ;
+      return ;
+  }
+
+  switch ( abs(style) )
+  {
+    case  PUSTYLE_PLAIN      :
+      glColor4fv ( colour [ mid ] ) ;
+      glRecti ( dx + min[0], dy + min[1],
+		dx + max[0], dy + max[1] ) ;
+      break ;
+
+    case  PUSTYLE_SMALL_BEVELLED   :
+    case  PUSTYLE_SMALL_SHADED     :
+      glColor4fv ( colour [ hi  ] ) ;
+      glBegin ( GL_QUAD_STRIP ) ;
+	glVertex2i ( dx + min[0] + PU_SMALL_BEVEL, dy + min[1] + PU_SMALL_BEVEL ) ;
+	glVertex2i ( dx + min[0], dy + min[1] ) ;
+	glVertex2i ( dx + min[0] + PU_SMALL_BEVEL, dy + max[1] - PU_SMALL_BEVEL ) ;
+	glVertex2i ( dx + min[0], dy + max[1] ) ;
+	glVertex2i ( dx + max[0] - PU_SMALL_BEVEL, dy + max[1] - PU_SMALL_BEVEL ) ;
+	glVertex2i ( dx + max[0], dy + max[1] ) ;
+      glEnd () ;
+	glColor4fv ( colour [ lo  ] ) ;
+      glBegin ( GL_QUAD_STRIP ) ;
+	glVertex2i ( dx + min[0], dy + min[1] ) ;
+	glVertex2i ( dx + min[0] + PU_SMALL_BEVEL, dy + min[1] + PU_SMALL_BEVEL ) ;
+	glVertex2i ( dx + max[0], dy + min[1] ) ;
+	glVertex2i ( dx + max[0] - PU_SMALL_BEVEL, dy + min[1] + PU_SMALL_BEVEL ) ;
+	glVertex2i ( dx + max[0], dy + max[1] ) ;
+	glVertex2i ( dx + max[0] - PU_SMALL_BEVEL, dy + max[1] - PU_SMALL_BEVEL ) ;
+      glEnd () ;
+
+      if ( abs(style) == PUSTYLE_SMALL_BEVELLED )
+      {
+        glColor4fv ( colour [ mid ] ) ;
+        glRecti ( dx + min[0] + PU_SMALL_BEVEL, dy + min[1] + PU_SMALL_BEVEL,
+		  dx + max[0] - PU_SMALL_BEVEL, dy + max[1] - PU_SMALL_BEVEL ) ;
+      }
+      else
+      {
+	glShadeModel(GL_SMOOTH);
+	glBegin(GL_POLYGON);
+	  glColor4fv( colour [ mid ] );
+	  glVertex2i( dx + min[0] + PU_SMALL_BEVEL , dy + min[1] + PU_SMALL_BEVEL );
+	  if(style==PUSTYLE_SMALL_SHADED)
+	    glColor4f( colour [mid][0] + (colour[lo][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[lo][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[lo][2] - colour[mid][2])/2.0f,
+		       colour [lo][3] );
+	  else
+	    glColor4f( colour [mid][0] + (colour[hi][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[hi][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[hi][2] - colour[mid][2])/2.0f,
+		       colour [hi][3] );
+	  glVertex2i( dx + min[0] + PU_SMALL_BEVEL , dy + max[1] - PU_SMALL_BEVEL );
+	  glColor4fv( colour [ mid ] );
+	  glVertex2i( dx + max[0] - PU_SMALL_BEVEL , dy + max[1] - PU_SMALL_BEVEL );
+	  if(style==-PUSTYLE_SMALL_SHADED)
+	    glColor4f( colour [mid][0] + (colour[lo][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[lo][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[lo][2] - colour[mid][2])/2.0f,
+		       colour [lo][3] );
+	  else
+	    glColor4f( colour [mid][0] + (colour[hi][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[hi][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[hi][2] - colour[mid][2])/2.0f,
+		       colour [hi][3] );
+	  glVertex2i( dx + max[0] - PU_SMALL_BEVEL , dy + min[1] + PU_SMALL_BEVEL );
+	glEnd();
+	glShadeModel(GL_FLAT);
+
+	if(style == -PUSTYLE_SMALL_SHADED)
+	{
+	  glColor4fv ( colour [ lo  ] ) ;
+	  glBegin ( GL_QUAD_STRIP ) ;
+	    glVertex2i ( dx + min[0] + PU_SMALL_BEVEL   , dy + min[1] + PU_SMALL_BEVEL   ) ;
+	    glVertex2i ( dx + min[0] + PU_SMALL_BEVEL/2 , dy + min[1] + PU_SMALL_BEVEL/2 ) ;
+	    glVertex2i ( dx + min[0] + PU_SMALL_BEVEL   , dy + max[1] - PU_SMALL_BEVEL   ) ;
+	    glVertex2i ( dx + min[0] + PU_SMALL_BEVEL/2 , dy + max[1] - PU_SMALL_BEVEL/2 ) ;
+	    glVertex2i ( dx + max[0] - PU_SMALL_BEVEL   , dy + max[1] - PU_SMALL_BEVEL   ) ;
+	    glVertex2i ( dx + max[0] - PU_SMALL_BEVEL/2 , dy + max[1] - PU_SMALL_BEVEL/2 ) ;
+	  glEnd () ;
+	  glColor4fv ( colour [ hi  ] ) ;
+	  glBegin ( GL_QUAD_STRIP ) ;
+	    glVertex2i ( dx + min[0] + PU_SMALL_BEVEL/2 , dy + min[1] + PU_SMALL_BEVEL/2 ) ;
+	    glVertex2i ( dx + min[0] + PU_SMALL_BEVEL   , dy + min[1] + PU_SMALL_BEVEL   ) ;
+	    glVertex2i ( dx + max[0] - PU_SMALL_BEVEL/2 , dy + min[1] + PU_SMALL_BEVEL/2 ) ;
+	    glVertex2i ( dx + max[0] - PU_SMALL_BEVEL   , dy + min[1] + PU_SMALL_BEVEL   ) ;
+	    glVertex2i ( dx + max[0] - PU_SMALL_BEVEL/2 , dy + max[1] - PU_SMALL_BEVEL/2 ) ;
+	    glVertex2i ( dx + max[0] - PU_SMALL_BEVEL   , dy + max[1] - PU_SMALL_BEVEL   ) ;
+	  glEnd () ;
+	}	
+      }
+      break ;
+
+    case  PUSTYLE_BEVELLED   :
+    case  PUSTYLE_SHADED     :
+      glColor4fv ( colour [ hi  ] ) ;
+      glBegin ( GL_QUAD_STRIP ) ;
+	glVertex2i ( dx + min[0] + PU_BEVEL, dy + min[1] + PU_BEVEL ) ;
+	glVertex2i ( dx + min[0], dy + min[1] ) ;
+	glVertex2i ( dx + min[0] + PU_BEVEL, dy + max[1] - PU_BEVEL ) ;
+	glVertex2i ( dx + min[0], dy + max[1] ) ;
+	glVertex2i ( dx + max[0] - PU_BEVEL, dy + max[1] - PU_BEVEL ) ;
+	glVertex2i ( dx + max[0], dy + max[1] ) ;
+      glEnd () ;
+	glColor4fv ( colour [ lo  ] ) ;
+      glBegin ( GL_QUAD_STRIP ) ;
+	glVertex2i ( dx + min[0], dy + min[1] ) ;
+	glVertex2i ( dx + min[0] + PU_BEVEL, dy + min[1] + PU_BEVEL ) ;
+	glVertex2i ( dx + max[0], dy + min[1] ) ;
+	glVertex2i ( dx + max[0] - PU_BEVEL, dy + min[1] + PU_BEVEL ) ;
+	glVertex2i ( dx + max[0], dy + max[1] ) ;
+	glVertex2i ( dx + max[0] - PU_BEVEL, dy + max[1] - PU_BEVEL ) ;
+      glEnd () ;
+
+      if ( abs(style) == PUSTYLE_BEVELLED )
+      {
+	glColor4fv ( colour [ mid ] ) ;
+	glRecti ( dx + min[0] + PU_BEVEL, dy + min[1] + PU_BEVEL,
+		  dx + max[0] - PU_BEVEL, dy + max[1] - PU_BEVEL ) ;
+      }
+      else
+      {
+	glShadeModel(GL_SMOOTH);
+	glBegin(GL_POLYGON);
+	  glColor4fv( colour [ mid ] );
+	  glVertex2i( dx + min[0] + PU_BEVEL , dy + min[1] + PU_BEVEL );
+	  if(style==PUSTYLE_SHADED)
+	    glColor4f( colour [mid][0] + (colour[lo][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[lo][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[lo][2] - colour[mid][2])/2.0f,
+		       colour [lo][3] );
+	  else
+	    glColor4f( colour [mid][0] + (colour[hi][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[hi][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[hi][2] - colour[mid][2])/2.0f,
+		       colour [hi][3] );
+	  glVertex2i( dx + min[0] + PU_BEVEL , dy + max[1] - PU_BEVEL );
+	  glColor4fv( colour [ mid ] );
+	  glVertex2i( dx + max[0] - PU_BEVEL , dy + max[1] - PU_BEVEL );
+	  if(style==-PUSTYLE_SHADED)
+	    glColor4f( colour [mid][0] + (colour[lo][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[lo][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[lo][2] - colour[mid][2])/2.0f,
+		       colour [lo][3] );
+	  else
+	    glColor4f( colour [mid][0] + (colour[hi][0] - colour[mid][0])/2.0f,
+		       colour [mid][1] + (colour[hi][1] - colour[mid][1])/2.0f,
+		       colour [mid][2] + (colour[hi][2] - colour[mid][2])/2.0f,
+		       colour [hi][3] );
+	  glVertex2i( dx + max[0] - PU_BEVEL , dy + min[1] + PU_BEVEL );
+	glEnd();
+	glShadeModel(GL_FLAT);
+
+	if(style == -PUSTYLE_SHADED)
+        {
+	  glColor4fv ( colour [ lo  ] ) ;
+	  glBegin ( GL_QUAD_STRIP ) ;
+	    glVertex2i ( dx + min[0] + PU_BEVEL   , dy + min[1] + PU_BEVEL   ) ;
+	    glVertex2i ( dx + min[0] + PU_BEVEL/2 , dy + min[1] + PU_BEVEL/2 ) ;
+	    glVertex2i ( dx + min[0] + PU_BEVEL   , dy + max[1] - PU_BEVEL   ) ;
+	    glVertex2i ( dx + min[0] + PU_BEVEL/2 , dy + max[1] - PU_BEVEL/2 ) ;
+	    glVertex2i ( dx + max[0] - PU_BEVEL   , dy + max[1] - PU_BEVEL   ) ;
+	    glVertex2i ( dx + max[0] - PU_BEVEL/2 , dy + max[1] - PU_BEVEL/2 ) ;
+	  glEnd () ;
+	  glColor4fv ( colour [ hi  ] ) ;
+	  glBegin ( GL_QUAD_STRIP ) ;
+	    glVertex2i ( dx + min[0] + PU_BEVEL/2 , dy + min[1] + PU_BEVEL/2 ) ;
+	    glVertex2i ( dx + min[0] + PU_BEVEL   , dy + min[1] + PU_BEVEL   ) ;
+	    glVertex2i ( dx + max[0] - PU_BEVEL/2 , dy + min[1] + PU_BEVEL/2 ) ;
+	    glVertex2i ( dx + max[0] - PU_BEVEL   , dy + min[1] + PU_BEVEL   ) ;
+	    glVertex2i ( dx + max[0] - PU_BEVEL/2 , dy + max[1] - PU_BEVEL/2 ) ;
+	    glVertex2i ( dx + max[0] - PU_BEVEL   , dy + max[1] - PU_BEVEL   ) ;
+	  glEnd () ;
+	}	
+      }	
+      break ;
+
+    case  PUSTYLE_BOXED      :
+      glColor4fv ( colour [ hi  ] ) ;
+      glRecti ( dx + min[0], dy + min[1],
+		dx + max[0], dy + max[1] ) ;
+      glColor4fv ( colour [ mid ] ) ;
+      glRecti ( dx + min[0]+PU_BOX_WIDTH, dy + min[1]+PU_BOX_WIDTH,
+		dx + max[0]-PU_BOX_WIDTH, dy + max[1]-PU_BOX_WIDTH ) ;
+      break ;
+
+    case  PUSTYLE_RADIO      :
+      glColor4fv ( colour [ lo  ] ) ;
+      glBegin ( GL_LINE_LOOP ) ;
+        glVertex2i ( dx + min[0] + PU_RADIO_BUTTON_SIZE/2, dy + min[1]                          ) ;
+        glVertex2i ( dx + min[0] + PU_RADIO_BUTTON_SIZE  , dy + min[1] + PU_RADIO_BUTTON_SIZE/2 ) ;
+        glVertex2i ( dx + min[0] + PU_RADIO_BUTTON_SIZE/2, dy + min[1] + PU_RADIO_BUTTON_SIZE   ) ;
+        glVertex2i ( dx + min[0]                         , dy + min[1] + PU_RADIO_BUTTON_SIZE/2 ) ;
+      glEnd () ;
+
+      if ( style < 0 )
+      {
+	glColor4fv ( colour [ hi  ] ) ;
+	glBegin ( GL_QUADS ) ;
+	  glVertex2i ( dx + min[0] + PU_RADIO_BUTTON_SIZE/2, dy + min[1] + 2                      ) ;
+	  glVertex2i ( dx + min[0] + PU_RADIO_BUTTON_SIZE-2, dy + min[1] + PU_RADIO_BUTTON_SIZE/2 ) ;
+	  glVertex2i ( dx + min[0] + PU_RADIO_BUTTON_SIZE/2, dy + min[1] + PU_RADIO_BUTTON_SIZE-2 ) ;
+	  glVertex2i ( dx + min[0] + 2                     , dy + min[1] + PU_RADIO_BUTTON_SIZE/2 ) ;
+	glEnd () ;
+      }
+      break ;
+
+    case  PUSTYLE_SPECIAL_UNDERLINED :
+      glColor4fv ( colour [ hi  ] ) ;
+      glRecti ( dx + min[0], dy + min[1],
+		dx + max[0], dy + min[1]+2 ) ;
+      glColor4fv ( colour [ mid ] ) ;
+      glRecti ( dx + min[0], dy + min[1]+1,
+		dx + max[0], dy + max[1] ) ;
+      break ;
+
+    case  PUSTYLE_DROPSHADOW :
+      glColor4fv ( colour [ lo  ] ) ;
+      glRecti ( dx + min[0] + PU_DROPSHADOW_OFFSET, dy + min[1] - PU_DROPSHADOW_OFFSET,
+		dx + max[0] + PU_DROPSHADOW_OFFSET, dy + max[1] - PU_DROPSHADOW_OFFSET ) ;
+      glColor4fv ( colour [ mid ] ) ;
+      glRecti ( dx + min[0], dy + min[1],
+		dx + max[0], dy + max[1] ) ;
+      break ;
+  }
+
+  if ( am_default )
+  {
+    glColor4fv ( colour [ PUCOL_BACKGROUND ] ) ;
+    glLineStipple ( 1, 0xF0F0 ) ;
+    glEnable ( GL_LINE_STIPPLE ) ;
+    glBegin ( GL_LINE_LOOP ) ;
+      glVertex2i ( dx + min[0] + PU_DFLT_OFFSET, dy + min[1] + PU_DFLT_OFFSET ) ;
+      glVertex2i ( dx + min[0] + PU_DFLT_OFFSET, dy + max[1] - PU_DFLT_OFFSET ) ;
+      glVertex2i ( dx + max[0] - PU_DFLT_OFFSET, dy + max[1] - PU_DFLT_OFFSET ) ;
+      glVertex2i ( dx + max[0] - PU_DFLT_OFFSET, dy + min[1] + PU_DFLT_OFFSET ) ;
+    glEnd () ;
+    glDisable ( GL_LINE_STIPPLE ) ;
+  }
+}
+
+
+
@@ -0,0 +1,61 @@
+
+
+#include "puLocal.h"
+
+void puButton::draw ( int dx, int dy )
+{
+  if ( !visible ) return ;
+
+  /* If button is pushed or highlighted - use inverse style for button itself */
+
+  int tempStyle;
+
+  if ( parent && ( ( parent->getType() & PUCLASS_POPUPMENU ) ||
+                   ( parent->getType() & PUCLASS_MENUBAR   ) ) )
+    tempStyle =  ( getValue() ^ highlighted ) ? PUSTYLE_SMALL_SHADED : style ;
+  else
+    tempStyle =  ( getValue() ^ highlighted ) ? -style : style ;
+
+  abox . draw ( dx, dy, tempStyle, colour, isReturnDefault() ) ;
+
+  /* If greyed out then halve the opacity when drawing the label and legend */
+
+  if ( active )
+    glColor4fv ( colour [ PUCOL_LEGEND ] ) ;
+  else
+    glColor4f ( colour [ PUCOL_LEGEND ][0],
+                colour [ PUCOL_LEGEND ][1],
+                colour [ PUCOL_LEGEND ][2],
+                colour [ PUCOL_LEGEND ][3] / 2.0f ) ; /* 50% more transparent */
+
+  int xx = ( abox.max[0] - abox.min[0] - puGetStringWidth(legendFont,legend) ) / 2 ;
+  int yy = ( abox.max[1] - abox.min[1] - puGetStringHeight(legendFont) ) / 2 ;
+
+  puDrawString ( legendFont, legend,
+                  dx + abox.min[0] + xx,
+                  dy + abox.min[1] + yy ) ;
+
+  draw_label ( dx, dy ) ;
+}
+
+
+void puButton::doHit ( int button, int updown, int, int )
+{
+
+
+  if ( button == PU_LEFT_BUTTON )
+  {
+    if ( updown == active_mouse_edge || active_mouse_edge == PU_UP_AND_DOWN )
+    {
+      lowlight () ;
+      setValue ( (int) ! getValue () ) ;
+      invokeCallback () ;
+    }
+    else
+      highlight () ;
+  }
+  else
+    lowlight () ;
+}
+
+
@@ -0,0 +1,100 @@
+
+#include "puLocal.h"
+
+puButtonBox::puButtonBox ( int minx, int miny, int maxx, int maxy,
+                char **labels, int one_button ) :
+                    puObject ( minx, miny, maxx, maxy )
+{
+  type |= PUCLASS_BUTTONBOX ;
+  one_only = one_button ;
+
+  button_labels = labels ;
+
+  for ( num_kids = 0 ; button_labels [ num_kids ] != NULL ; num_kids++ )
+    /* Count number of labels */ ;
+}
+
+
+int puButtonBox::checkKey ( int key, int updown )
+{
+  if ( updown == PU_UP ||
+       ! isReturnDefault() ||
+       ( key != '\r' && key != '\n' ) )
+    return FALSE ;
+
+  int v = getValue () ;
+
+  if ( ! one_only )
+    v = ~v ;
+  else
+  if ( v++ > num_kids )
+    v = 0 ;
+
+  setValue ( v ) ;
+  invokeCallback() ;
+  return TRUE ;
+}
+
+
+int puButtonBox::checkHit ( int button, int updown, int x, int y )
+{
+  if ( ! isHit ( x, y ) ||
+       ( updown != active_mouse_edge &&
+         active_mouse_edge != PU_UP_AND_DOWN ) )
+    return FALSE ;
+
+  int i = num_kids - 1 - (( y - abox.min[1] - PUSTR_BGAP ) * num_kids ) /
+                          ( abox.max[1] - abox.min[1] - PUSTR_BGAP - PUSTR_TGAP ) ;
+
+  if ( i < 0 ) i = 0 ;
+  if ( i >= num_kids ) i = num_kids - 1 ;
+
+  if ( one_only )
+    setValue ( i ) ;
+  else
+    setValue ( getValue () ^ ( 1 << i ) ) ;
+
+  invokeCallback () ;
+  return TRUE ;
+}
+
+
+void puButtonBox::draw ( int dx, int dy )
+{
+  if ( !visible ) return ;
+
+  abox . draw ( dx, dy, style, colour, isReturnDefault() ) ;
+
+  for ( int i = 0 ; i < num_kids ; i++ )
+  {
+    puBox tbox ;
+
+    tbox . min [ 0 ] = abox.min [ 0 ] + PUSTR_LGAP + PUSTR_LGAP ;
+    tbox . min [ 1 ] = abox.min [ 1 ] + ((abox.max[1]-abox.min[1]-PUSTR_TGAP-PUSTR_BGAP)/num_kids) * (num_kids-1-i) ;
+    tbox . max [ 0 ] = tbox.min [ 0 ] ;
+    tbox . max [ 1 ] = tbox.min [ 1 ] ;
+
+    if (( one_only && i == getValue() ) ||
+        ( !one_only && ((1<<i) & getValue() ) != 0 ) ) 
+      tbox . draw ( dx, dy + PUSTR_BGAP + PUSTR_BGAP, -PUSTYLE_RADIO, colour, FALSE ) ;
+    else
+      tbox . draw ( dx, dy + PUSTR_BGAP + PUSTR_BGAP, PUSTYLE_RADIO, colour, FALSE ) ;
+
+    /* If greyed out then halve the opacity when drawing the label and legend */
+
+    if ( active )
+      glColor4fv ( colour [ PUCOL_LEGEND ] ) ;
+    else
+      glColor4f ( colour [ PUCOL_LEGEND ][0],
+                  colour [ PUCOL_LEGEND ][1],
+                  colour [ PUCOL_LEGEND ][2],
+                  colour [ PUCOL_LEGEND ][3] / 2.0f ) ; /* 50% more transparent */
+
+    puDrawString ( legendFont, button_labels[i],
+                   dx + tbox.min[0] + PU_RADIO_BUTTON_SIZE + PUSTR_LGAP,
+                   dy + tbox.min[1] + puGetStringDescender(legendFont) + PUSTR_BGAP  + PUSTR_BGAP) ;
+  }
+
+  draw_label ( dx, dy ) ;
+}
+
@@ -0,0 +1,4 @@
+
+#include "puLocal.h"
+
+
@@ -0,0 +1,30 @@
+
+
+#include "puLocal.h"
+
+void puFrame::draw ( int dx, int dy )
+{
+  if ( !visible ) return ;
+
+  abox . draw ( dx, dy, style, colour, FALSE ) ;
+
+  /* If greyed out then halve the opacity when drawing the label and legend */
+
+  if ( active )
+    glColor4fv ( colour [ PUCOL_LEGEND ] ) ;
+  else
+    glColor4f ( colour [ PUCOL_LEGEND ][0],
+                colour [ PUCOL_LEGEND ][1],
+                colour [ PUCOL_LEGEND ][2],
+                colour [ PUCOL_LEGEND ][3] / 2.0f ) ; /* 50% more transparent */
+
+  int xx = ( abox.max[0] - abox.min[0] - puGetStringWidth ( legendFont, legend ) ) / 2 ;
+
+  puDrawString ( legendFont, legend,
+                  dx + abox.min[0] + xx,
+                  dy + abox.min[1] + puGetStringDescender ( legendFont ) + PUSTR_BGAP ) ;
+
+  draw_label ( dx, dy ) ;
+}
+
+
@@ -0,0 +1,226 @@
+
+#include "puLocal.h"
+
+void puInput::normalize_cursors ( void )
+{
+  char val [ PUSTRING_MAX ] ;
+  getValue ( val ) ;
+  int sl = strlen ( val ) ;
+
+  /* Clamp the positions to the limits of the text.  */
+
+  if ( cursor_position       <  0 ) cursor_position       =  0 ;
+  if ( select_start_position <  0 ) select_start_position =  0 ;
+  if ( select_end_position   <  0 ) select_end_position   =  0 ;
+  if ( cursor_position       > sl ) cursor_position       = sl ;
+  if ( select_start_position > sl ) select_start_position = sl ;
+  if ( select_end_position   > sl ) select_end_position   = sl ;
+
+  /* Swap the ends of the select window if they get crossed over */
+
+  if ( select_end_position < select_start_position )
+  {
+    int tmp = select_end_position ;     
+    select_end_position = select_start_position ;     
+    select_start_position = tmp ;
+  }
+}
+
+void puInput::draw ( int dx, int dy )
+{
+  normalize_cursors () ;
+
+  if ( !visible ) return ;
+
+  /* 3D Input boxes look nicest if they are always in inverse style. */
+
+  abox . draw ( dx, dy, ( (style==PUSTYLE_SMALL_BEVELLED ||
+                           style==PUSTYLE_SMALL_SHADED) ) ? -style :
+                        (accepting ? -style : style ), colour, FALSE ) ;
+
+  int xx = puGetStringWidth ( legendFont, " " ) ;
+  int yy = ( abox.max[1] - abox.min[1] - puGetStringHeight(legendFont) ) / 2 ;
+
+  if ( accepting )
+  {
+    char val [ PUSTRING_MAX ] ;
+    getValue ( val ) ;
+
+    /* Highlight the select area */
+
+    if ( select_end_position > 0 &&
+         select_end_position != select_start_position )    
+    {
+      val [ select_end_position ] = '\0' ;
+      int cpos2 = puGetStringWidth ( legendFont, val ) + xx + dx + abox.min[0] ;
+      val [ select_start_position ] = '\0' ;
+      int cpos1 = puGetStringWidth ( legendFont, val ) + xx + dx + abox.min[0] ;
+
+      glColor3f ( 1.0f, 1.0f, 0.7f ) ;
+      glRecti ( cpos1, dy + abox.min[1] + 6 ,
+                cpos2, dy + abox.max[1] - 6 ) ;
+    }
+  }
+
+  /* Draw the text */
+
+  {
+    /* If greyed out then halve the opacity when drawing the label and legend */
+
+    if ( active )
+      glColor4fv ( colour [ PUCOL_LEGEND ] ) ;
+    else
+      glColor4f ( colour [ PUCOL_LEGEND ][0],
+		  colour [ PUCOL_LEGEND ][1],
+		  colour [ PUCOL_LEGEND ][2],
+		  colour [ PUCOL_LEGEND ][3] / 2.0f ) ; /* 50% more transparent */
+
+    char val [ PUSTRING_MAX ] ;
+    getValue ( val ) ;
+
+    puDrawString ( legendFont, val,
+                  dx + abox.min[0] + xx,
+                  dy + abox.min[1] + yy ) ;
+
+    draw_label ( dx, dy ) ;
+  }
+
+  if ( accepting )
+  { 
+    char val [ PUSTRING_MAX ] ;
+    getValue ( val ) ;
+
+    /* Draw the 'I' bar cursor. */
+
+    if ( cursor_position >= 0 )
+    {
+      val [ cursor_position ] = '\0' ;
+
+      int cpos = puGetStringWidth ( legendFont, val ) + xx + dx + abox.min[0] ;
+
+      glColor3f ( 0.1f, 0.1f, 1.0f ) ;
+      glBegin   ( GL_LINES ) ;
+      glVertex2i ( cpos    , dy + abox.min[1] + 7 ) ;
+      glVertex2i ( cpos    , dy + abox.max[1] - 7 ) ;
+      glVertex2i ( cpos - 1, dy + abox.min[1] + 7 ) ;
+      glVertex2i ( cpos - 1, dy + abox.max[1] - 7 ) ;
+      glVertex2i ( cpos - 4, dy + abox.min[1] + 7 ) ;
+      glVertex2i ( cpos + 3, dy + abox.min[1] + 7 ) ;
+      glVertex2i ( cpos - 4, dy + abox.max[1] - 7 ) ;
+      glVertex2i ( cpos + 3, dy + abox.max[1] - 7 ) ;
+      glEnd      () ;
+    }
+  }
+}
+
+
+void puInput::doHit ( int button, int updown, int x, int /* y */ )
+{
+  if ( button == PU_LEFT_BUTTON )
+  {
+    /* Most GUI's activate a button on button-UP not button-DOWN. */
+
+    if ( updown == active_mouse_edge || active_mouse_edge == PU_UP_AND_DOWN )
+    {
+      lowlight () ;
+
+      char *strval ;
+      getValue ( & strval ) ;
+      char *tmpval = new char [ strlen(strval) + 1 ] ;
+      strcpy ( tmpval, strval ) ;
+
+      int i = strlen ( tmpval ) ;
+
+      while ( x <= puGetStringWidth ( legendFont, tmpval ) + abox.min[0] &&
+              i >= 0 )
+        tmpval[--i] = '\0' ;
+    
+      accepting = TRUE ;
+      cursor_position = i ;
+      normalize_cursors () ;
+      invokeCallback () ;
+    }
+    else
+      highlight () ;
+  }
+  else
+    lowlight () ;
+}
+
+int puInput::checkKey ( int key, int updown )
+{
+  (updown,updown);
+
+  if ( ! isAcceptingInput() || ! isActive () || ! isVisible () )
+    return FALSE ;
+
+  normalize_cursors () ;
+
+  char *p ;
+
+  switch ( key )
+  {
+    case PU_KEY_PAGE_UP   :
+    case PU_KEY_PAGE_DOWN :
+    case PU_KEY_INSERT    : return FALSE ; 
+
+    case PU_KEY_UP   :
+    case PU_KEY_DOWN :
+    case 0x1B /* ESC */ :
+    case '\t' :
+    case '\r' :
+    case '\n' : /* Carriage return/Line Feed/TAB  -- End of input */
+      rejectInput () ;
+      normalize_cursors () ;
+      invokeCallback () ;
+      break ;
+
+    case '\b' : /* Backspace */
+      if ( cursor_position > 0 ) 
+        for ( p = & string [ --cursor_position ] ; *p != '\0' ; p++ )
+          *p = *(p+1) ;
+      break ;
+
+    case 0x7F : /* DEL */
+      if ( select_start_position != select_end_position )
+      {
+        char *p1 = & string [ select_start_position ] ;
+        char *p2 = & string [ select_end_position   ] ;
+
+        while ( *p1 != '\0' )
+          *p1++ = *p2++ ;
+
+        select_end_position = select_start_position ;
+      }
+      else
+	for ( p = & string [ cursor_position ] ; *p != '\0' ; p++ )
+	  *p = *(p+1) ;
+      break ;
+
+    case 0x15 /* ^U */ : string [ 0 ] = '\0' ; break ;
+    case PU_KEY_HOME   : cursor_position = 0 ; break ;
+    case PU_KEY_END    : cursor_position = PUSTRING_MAX ; break ;
+    case PU_KEY_LEFT   : cursor_position-- ; break ;
+    case PU_KEY_RIGHT  : cursor_position++ ; break ;
+
+    default:
+      if ( key < ' ' || key > 127 ) return FALSE ;
+
+      if ( strlen ( string ) >= PUSTRING_MAX )
+        return FALSE ;
+
+      for ( p = & string [ strlen(string) ] ;
+               p != &string[cursor_position] ; p-- )
+        *(p+1) = *p ;
+
+      *p = key ;
+      cursor_position++ ;
+      break ;
+  }
+
+  setValue ( string ) ;
+  normalize_cursors () ;
+  return TRUE ;
+}
+
+
@@ -0,0 +1,268 @@
+
+#include "puLocal.h"
+
+#define PUSTACK_MAX 100
+
+static int currLiveInterface = -1 ;
+static puInterface *liveInterfaceStack [ PUSTACK_MAX ] ;
+static int currInterface = -1 ;
+static puInterface *interfaceStack [ PUSTACK_MAX ] ;
+
+void puPushLiveInterface ( puInterface *in )
+{
+  if ( currLiveInterface < PUSTACK_MAX )
+    liveInterfaceStack [ ++currLiveInterface ] = in ;
+  else
+    fprintf ( stderr, "PUI: Too many live puInterfaces open at once!\n" ) ;
+}
+
+void puPushInterface ( puInterface *in )
+{
+  if ( currInterface < PUSTACK_MAX )
+    interfaceStack [ ++currInterface ] = in ;
+  else
+    fprintf ( stderr, "PUI: Too many puInterfaces open at once!\n" ) ;
+}
+
+void  puPopLiveInterface ( void )
+{
+  if ( currLiveInterface > 0 )
+    --currLiveInterface ;
+  else 
+    fprintf ( stderr, "PUI: Live puInterface stack is empty!\n" ) ;
+}
+
+void  puPopInterface ( void )
+{
+  if ( currInterface > 0 )
+    --currInterface ;
+  else 
+    fprintf ( stderr, "PUI: puInterface stack is empty!\n" ) ;
+}
+
+int  puNoLiveInterface ( void )
+{
+  return currLiveInterface < 0 ;
+}
+
+int  puNoInterface ( void )
+{
+  return currInterface < 0 ;
+}
+
+puInterface *puGetUltimateLiveInterface ( void )
+{
+  if ( currLiveInterface < 0 )
+  {
+    fprintf ( stderr, "PUI: No Live Interface!\n" ) ;
+    return NULL ;
+  }
+
+  return liveInterfaceStack [ 0 ] ;
+}
+
+
+puInterface *puGetBaseLiveInterface ( void )
+{
+  if ( currLiveInterface < 0 )
+  {
+    fprintf ( stderr, "PUI: No Live Interface!\n" ) ;
+    return NULL ;
+  }
+
+  /*
+    Work down the interface stack until you
+    either get to the bottom or find a block
+    in the form of a puDialogBox.
+  */
+
+  for ( int i = currLiveInterface ; i > 0 ; i-- )
+    if ( liveInterfaceStack [ i ] -> getType () & PUCLASS_DIALOGBOX )
+      return liveInterfaceStack [ i ] ; 
+
+  return liveInterfaceStack [ 0 ] ;
+}
+
+puInterface *puGetCurrInterface ( void )
+{
+  if ( currInterface < 0 )
+  {
+    fprintf ( stderr, "PUI: No Interface!\n" ) ;
+    return NULL ;
+  }
+
+  return interfaceStack [ currInterface ] ;
+}
+
+void puInterface::remove ( puObject *obj )
+{
+  if ( dlist == NULL )
+    return ;
+
+  /* Are we the first object in the list */
+
+  if ( obj -> prev == NULL )
+    dlist = obj -> next ;
+  else
+    obj -> prev -> next = obj -> next ;
+
+  /* Are we the last object in the list */
+
+  if ( obj -> next != NULL )
+    obj -> next -> prev = obj -> prev ;
+
+  obj -> next = NULL ;
+  obj -> prev = NULL ;
+
+  num_children-- ;
+  recalc_bbox () ;
+}
+
+void puInterface::add ( puObject *new_obj )
+{
+  if ( dlist == NULL )
+  {
+    dlist = new_obj ;
+    new_obj -> next = NULL ;
+    new_obj -> prev = NULL ;
+  }
+  else
+  {
+    puObject *last ;
+
+    for ( last = dlist ; last->next != NULL ; last = last->next )
+      /* Search for end of list. */ ;
+
+    last -> next = new_obj ;
+    new_obj -> prev = last ;
+    new_obj -> next = NULL ;
+  }
+
+  num_children++ ;
+  recalc_bbox () ;
+}
+
+int puInterface::checkKey ( int key, int updown )
+{
+  if ( dlist == NULL || ! isVisible () || ! isActive () )
+    return FALSE ;
+
+  puObject *bo ;
+
+  /*
+    We have to walk the list backwards to ensure that
+    the click order is the same as the DRAW order.
+  */
+
+  for ( bo = dlist ; bo->next != NULL ; bo = bo->next )
+    /* Find the last object in our list. */ ;
+
+  for ( ; bo != NULL ; bo = bo->prev )
+    if ( bo -> checkKey ( key, updown ) )
+      return TRUE ;
+
+  return FALSE ;
+}
+
+int puInterface::checkHit ( int button, int updown, int x, int y )
+{
+  if ( dlist == NULL || ! isVisible () || ! isActive () )
+    return FALSE ;
+
+  /*
+    This might be a bit redundant - but it's too hard to keep
+    track of changing abox sizes when daughter objects are
+    changing sizes.
+  */
+
+  recalc_bbox () ;
+
+  puObject *bo ;
+
+  x -= abox.min[0] ;
+  y -= abox.min[1] ;
+
+  /*
+    We have to walk the list backwards to ensure that
+    the click order is the same as the DRAW order.
+  */
+
+  for ( bo = dlist ; bo->next != NULL ; bo = bo->next )
+    /* Find the last object in our list. */ ;
+
+  for ( ; bo != NULL ; bo = bo->prev )
+    if ( bo -> checkHit ( button, updown, x, y ) )
+      return TRUE ;
+
+  return FALSE ;
+}
+
+
+void puInterface::draw ( int dx, int dy )
+{
+  if ( ! isVisible () )
+    return ;
+
+  for ( puObject *bo = dlist ; bo != NULL ; bo = bo->next )
+  {
+    /* June 16th, 98, Shammi :
+     * The next if statement checks if the object is
+     * a menu bar and makes sure it is repositioned
+     * correctly.
+     */
+
+    if ( bo->getType() & PUCLASS_MENUBAR )
+    {
+      int obWidth, obHeight ;
+      bo -> getSize ( &obWidth, &obHeight ) ;
+      bo -> setPosition ( 0, puGetWindowHeight() - obHeight ) ;
+    }
+
+    bo -> draw ( dx + abox.min[0], dy + abox.min[1] ) ;
+  }
+}
+
+
+void puInterface::recalc_bbox ( void ) 
+{
+  puBox contents ;
+  contents . empty () ;
+
+  for ( puObject *bo = dlist ; bo != NULL ; bo = bo->next )
+    contents . extend ( bo -> getBBox() ) ;
+
+  if ( contents . isEmpty () )
+  {
+    abox . max[0] = abox . min[0] ;
+    abox . max[1] = abox . min[1] ;
+  }
+  else
+  {
+    abox . max[0] = abox . min[0] + contents . max[0] ;
+    abox . max[1] = abox . min[1] + contents . max[1] ;
+  }
+
+  puObject::recalc_bbox () ;
+}
+
+
+void puInterface::doHit ( int, int, int, int )
+{
+}
+
+
+puInterface::~puInterface ()
+{
+    puPopLiveInterface () ;
+
+    puObject *bo = dlist ;
+
+    while ( bo != NULL ) {
+	puObject *tmp_bo = bo->next ;
+	delete bo ;
+	bo = tmp_bo ;
+    }
+}
+
+
+
@@ -0,0 +1,19 @@
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+#include <math.h>
+
+#ifndef PU_NOT_USING_GLUT
+#include <GL/glut.h>
+#endif
+#include "pu.h"
+
@@ -0,0 +1,83 @@
+
+#include "puLocal.h"
+
+void drop_down_the_menu ( puObject *b )
+{
+  puPopupMenu *p = (puPopupMenu *) b -> getUserData () ;
+
+  if ( b -> getValue () )
+    p->reveal () ;
+  else
+    p->hide () ;
+
+  for ( puObject *child = b -> getParent () -> getFirstChild () ;
+        child != NULL ; child = child -> next )
+  {
+    if (( child -> getType() & PUCLASS_BUTTON    ) != 0 && child != b ) child -> clrValue () ;
+    if (( child -> getType() & PUCLASS_POPUPMENU ) != 0 && child != p ) child -> hide     () ;
+  }
+}
+
+void puMenuBar::add_submenu ( char *str, char *items[], puCallback cb[] )
+{
+  int w, h ;
+  getSize ( &w, &h ) ;
+
+  puOneShot    *b = new puOneShot ( w+10, 0, str ) ;
+  b -> setStyle ( PUSTYLE_SPECIAL_UNDERLINED ) ;
+  b -> setColourScheme ( colour[PUCOL_FOREGROUND][0],
+                         colour[PUCOL_FOREGROUND][1],
+                         colour[PUCOL_FOREGROUND][2],
+                         colour[PUCOL_FOREGROUND][3] ) ;
+  b -> setCallback ( drop_down_the_menu ) ;
+  b -> setActiveDirn ( PU_UP_AND_DOWN ) ;
+
+  puPopupMenu *p = new puPopupMenu ( w+10, 0 ) ;
+
+  b -> setUserData ( p ) ;
+
+  for ( int i = 0 ; items[i] != NULL ; i++ )
+    p -> add_item ( items[i], cb[i] ) ;
+
+  p->close () ;
+  recalc_bbox () ;
+}
+
+void puMenuBar::close (void)
+{
+  puInterface::close () ;
+
+  if ( dlist == NULL )
+    return ;
+
+  int width = 0 ;
+  puObject *ob ;
+
+  /*
+    Use alternate objects - which gets the puOneShot/puPopupMenu pairs
+  */
+
+  for ( ob = dlist ; ob != NULL ; ob = ob -> next )
+  {
+    int w, h ;
+
+    /* Reposition the button so it looks nice */
+
+    ob -> getSize ( &w, &h ) ;
+    ob -> setPosition ( width, 0 ) ;
+    ob = ob -> next ;
+
+    /* Reposition the submenu so it sits under the button */
+
+    int w2, h2 ;
+    ob -> getSize ( &w2, &h2 ) ;
+    ob -> setPosition ( width, -h2 ) ;
+
+    /* Next please! */
+    width += w ;
+  }
+
+  recalc_bbox () ;
+}
+
+
@@ -0,0 +1,222 @@
+
+#include "puLocal.h"
+
+inline float clamp01 ( float x )
+{
+  return (x >= 1.0f) ? 1.0f : x ;
+}
+
+static void load_colour_scheme ( float col[][4], float r, float g,
+                                                 float b, float a )
+{
+  puSetColour ( col [ PUCOL_FOREGROUND ], r, g, b, a ) ;
+  puSetColour ( col [ PUCOL_BACKGROUND ], r/2, g/2, b/2, a ) ;
+  puSetColour ( col [ PUCOL_HIGHLIGHT  ], clamp01(r*1.3f), clamp01(g*1.3f),
+                                             clamp01(b*1.3f), a ) ;
+
+  if ( 4 * g + 3 * r + b > 0.5 )
+    puSetColour ( col [ PUCOL_LEGEND ], 0.0, 0.0, 0.0, a ) ;
+  else
+    puSetColour ( col [ PUCOL_LEGEND ], 1.0, 1.0, 1.0, a ) ;
+}
+
+
+static int    defaultStyle = PUSTYLE_DEFAULT ;
+static puFont defaultLegendFont = NULL ;
+static puFont defaultLabelFont  = NULL ;
+static float  defaultColourScheme [ 4 ] ;
+
+void puSetDefaultStyle ( int  style ) { defaultStyle = style ; }
+int   puGetDefaultStyle ( void ) { return defaultStyle ; }
+
+void puSetDefaultFonts ( puFont legendFont, puFont labelFont )
+{
+  defaultLegendFont = legendFont ;
+  defaultLabelFont  = labelFont ;
+}
+
+void puGetDefaultFonts ( puFont *legendFont, puFont *labelFont )
+{
+  if ( legendFont ) *legendFont = defaultLegendFont ;
+  if ( labelFont  ) *labelFont  = defaultLabelFont  ;
+}
+
+void puSetDefaultColourScheme ( float r, float g, float b, float a )
+{
+  defaultColourScheme[0] = r ;
+  defaultColourScheme[1] = g ;
+  defaultColourScheme[2] = b ;
+  defaultColourScheme[3] = a ;
+  load_colour_scheme ( _puDefaultColourTable, r, g, b, a ) ;
+}
+
+void puGetDefaultColourScheme ( float *r, float *g, float *b, float *a )
+{
+  if ( r ) *r = defaultColourScheme[0] ;
+  if ( g ) *g = defaultColourScheme[1] ;
+  if ( b ) *b = defaultColourScheme[2] ;
+  if ( a ) *a = defaultColourScheme[3] ;
+}
+
+
+
+void puObject::setColourScheme ( float r, float g, float b, float a )
+{
+  load_colour_scheme ( colour, r, g, b, a ) ;
+}
+
+puObject::puObject ( int minx, int miny, int maxx, int maxy ) : puValue ()
+{
+  type |= PUCLASS_OBJECT ;
+  bbox.min[0] = abox.min[0] = minx ;
+  bbox.min[1] = abox.min[1] = miny ;
+  bbox.max[0] = abox.max[0] = maxx ;
+  bbox.max[1] = abox.max[1] = maxy ;
+
+  active_mouse_edge = PU_UP ;
+  style      = defaultStyle ;
+  visible = active  = TRUE  ;
+  highlighted       = FALSE ;
+  am_default        = FALSE ;
+
+  cb          = NULL ;
+  user_data   = NULL ;
+  next = prev = NULL ;
+  label       = NULL ;
+  labelPlace  = PUPLACE_DEFAULT   ;
+  labelFont   = defaultLabelFont  ;
+  legend      = NULL ;
+  legendFont  = defaultLegendFont ;
+
+  for ( int i = 0 ; i < PUCOL_MAX ; i++ )
+    puSetColour ( colour[i], _puDefaultColourTable[i] ) ;
+
+  if ( ! puNoInterface() )
+  {
+    parent = puGetCurrInterface() ;
+    parent -> add ( this ) ;
+  }
+  else
+    parent = NULL ;
+}
+
+
+puObject::~puObject ()
+{
+  if ( parent != this && parent != NULL )
+    parent -> remove ( this ) ;
+}
+
+void puObject::recalc_bbox ( void )
+{
+  bbox = abox ;
+
+  if ( label != NULL )
+    switch ( labelPlace )
+    {
+      case PUPLACE_ABOVE : bbox.max[1] += puGetStringHeight ( getLabelFont() ) + puGetStringDescender ( getLabelFont () ) + PUSTR_TGAP + PUSTR_BGAP ; break ;
+      case PUPLACE_BELOW : bbox.min[1] -= puGetStringHeight ( getLabelFont() ) + puGetStringDescender ( getLabelFont () ) + PUSTR_TGAP + PUSTR_BGAP ; break ;
+      case PUPLACE_LEFT  : bbox.min[0] -= puGetStringWidth  ( getLabelFont(), getLabel() ) + PUSTR_LGAP + PUSTR_RGAP ; break ;
+      case PUPLACE_RIGHT : bbox.max[0] += puGetStringWidth  ( getLabelFont(), getLabel() ) + PUSTR_LGAP + PUSTR_RGAP ; break ;
+    }
+
+  if ( parent != NULL )
+    parent -> recalc_bbox () ;
+}
+
+void puObject::draw_label ( int dx, int dy )
+{
+  if ( !visible ) return ;
+
+  /* If greyed out then halve the opacity when drawing the label */
+
+  if ( active )
+    glColor4fv ( colour [ PUCOL_LABEL ] ) ;
+  else
+    glColor4f ( colour [ PUCOL_LABEL ][0],
+                colour [ PUCOL_LABEL ][1],
+                colour [ PUCOL_LABEL ][2],
+                colour [ PUCOL_LABEL ][3] / 2.0f ) ; /* 50% more transparent */
+
+  switch ( labelPlace )
+  {
+    case PUPLACE_ABOVE : puDrawString ( labelFont, label, dx + abox.min[0] + PUSTR_LGAP, dy + abox.max[1] + puGetStringDescender(labelFont) + PUSTR_BGAP ) ; break ;
+    case PUPLACE_BELOW : puDrawString ( labelFont, label, dx + abox.min[0] + PUSTR_LGAP, dy + bbox.min[1] + puGetStringDescender(labelFont) + PUSTR_BGAP ) ; break ;
+    case PUPLACE_LEFT  : puDrawString ( labelFont, label, dx + bbox.min[0] + PUSTR_LGAP, dy + abox.min[1] + puGetStringDescender(labelFont) + PUSTR_BGAP ) ; break ;
+    case PUPLACE_RIGHT : puDrawString ( labelFont, label, dx + abox.max[0] + PUSTR_LGAP, dy + abox.min[1] + puGetStringDescender(labelFont) + PUSTR_BGAP ) ; break ;
+  }
+}
+
+
+int puObject::checkKey ( int key, int updown )
+{
+  if ( updown == PU_UP )
+    return FALSE ;
+
+  if ( isReturnDefault() && ( key == '\r' || key == '\n' ) )
+  {
+    checkHit ( PU_LEFT_BUTTON, PU_DOWN, (abox.min[0]+abox.max[0])/2,
+                                        (abox.min[1]+abox.max[1])/2 ) ;
+    checkHit ( PU_LEFT_BUTTON, PU_UP  , (abox.min[0]+abox.max[0])/2,
+                                        (abox.min[1]+abox.max[1])/2 ) ;
+    return TRUE ;
+  }
+
+  return FALSE ;
+}
+
+
+void puObject::doHit ( int button, int updown, int x, int y )
+{
+  (x,x);(y,y);
+
+  if ( button == PU_LEFT_BUTTON )
+  {
+    if ( updown == active_mouse_edge || active_mouse_edge == PU_UP_AND_DOWN )
+    {
+      lowlight () ;
+      invokeCallback () ;
+    }
+    else
+      highlight () ;
+  }
+  else
+    lowlight () ;
+}
+
+int puObject::checkHit ( int button, int updown, int x, int y )
+{
+  if ( isHit( x, y ) )
+  {
+    doHit ( button, updown, x, y ) ;
+    return TRUE ;
+  }
+
+  lowlight () ;
+  return FALSE ;
+}
+
+ 
+char *puValue::getTypeString ( void )
+{
+  int i = getType () ;
+
+  if ( i & PUCLASS_DIALOGBOX   ) return "puDialogBox" ;
+  if ( i & PUCLASS_SLIDER      ) return "puSlider" ;
+  if ( i & PUCLASS_BUTTONBOX   ) return "puButtonBox" ;
+  if ( i & PUCLASS_INPUT       ) return "puInput" ;
+  if ( i & PUCLASS_MENUBAR     ) return "puMenuBar" ;
+  if ( i & PUCLASS_POPUPMENU   ) return "puPopupMenu" ;
+  if ( i & PUCLASS_POPUP       ) return "puPopup" ;
+  if ( i & PUCLASS_ONESHOT     ) return "puOneShot" ;
+  if ( i & PUCLASS_BUTTON      ) return "puButton" ;
+  if ( i & PUCLASS_TEXT        ) return "puText" ;
+  if ( i & PUCLASS_FRAME       ) return "puFrame" ;
+  if ( i & PUCLASS_INTERFACE   ) return "puInterface" ;
+  if ( i & PUCLASS_OBJECT      ) return "puObject" ;
+  if ( i & PUCLASS_VALUE       ) return "puValue" ;
+
+  return "Unknown Object type." ;
+}
+
+
@@ -0,0 +1,9 @@
+
+#include "puLocal.h"
+
+void puOneShot::doHit ( int button, int updown, int x, int y )
+{
+  puButton::doHit ( button, updown, x, y ) ;
+  setValue ( 0 ) ;
+}
+
@@ -0,0 +1,3 @@
+
+#include "puLocal.h"
+
@@ -0,0 +1,175 @@
+#include "puLocal.h"
+
+#define PUMENU_BUTTON_HEIGHT       25
+#define PUMENU_BUTTON_EXTRA_WIDTH  25
+
+puObject *puPopupMenu::add_item ( char *str, puCallback cb )
+{
+  int w, h ;
+  getSize ( &w, &h ) ;
+  puOneShot *b = new puOneShot ( 0, h, str ) ;
+  b->setStyle        ( PUSTYLE_PLAIN ) ;
+  b->setColourScheme ( colour[PUCOL_FOREGROUND][0],
+		       colour[PUCOL_FOREGROUND][1],
+		       colour[PUCOL_FOREGROUND][2],
+		       colour[PUCOL_FOREGROUND][3] ) ;
+  b->setCallback     ( cb ) ;
+  recalc_bbox () ;
+  return b ;
+}
+
+void puPopupMenu::close ( void )
+{
+  puPopup::close () ;
+
+  int widest = 0 ;
+  puObject *ob = dlist ;
+
+  /*
+   * June 17th, 1998, Shammi
+   * There seems to be some mismatch with the
+   * #define pumenusize and the actual size
+   * There seems to be some overlap resulting
+   * in more than one option being highlighted.
+   * By setting the size to the actual values,
+   * the overlap area seems to be less now.
+   */
+
+  int w, h ;
+
+  for ( ob = dlist ; ob != NULL ; ob = ob -> next )
+  {
+    ob -> getSize ( &w, &h ) ;
+
+    if ( w > widest ) widest = w ;
+  }
+
+  for ( ob = dlist ; ob != NULL ; ob = ob -> next )
+  {
+    ob -> getSize ( &w, &h ) ;
+    ob -> setSize ( widest, h ) ;
+  }
+
+  recalc_bbox () ;
+}
+
+
+int puPopupMenu::checkKey ( int key, int updown )
+{
+  if ( dlist == NULL || ! isVisible () || ! isActive () )
+    return FALSE ;
+
+  if ( updown == PU_DOWN )
+  {
+    hide () ;
+
+    /* Turn everything off ready for next time. */
+
+    for ( puObject *bo = dlist ; bo != NULL ; bo = bo->next )
+      bo -> clrValue () ;
+  }
+
+  puObject *bo ;
+
+  /*
+    We have to walk the list backwards to ensure that
+    the click order is the same as the DRAW order.
+  */
+
+  for ( bo = dlist ; bo->next != NULL ; bo = bo->next )
+    /* Find the last object in our list. */ ;
+
+  for ( ; bo != NULL ; bo = bo->prev )
+    if ( bo -> checkKey ( key, updown ) )
+      return TRUE ;
+
+  return FALSE ;
+}
+
+
+int puPopupMenu::checkHit ( int button, int updown, int x, int y )
+{
+  if ( dlist == NULL || ! isVisible () || ! isActive () )
+    return FALSE ;
+
+  /* Must test 'isHit' before making the menu invisible! */
+
+  int hit = isHit ( x, y ) ;
+
+  /*
+   * June 17th, 1998, Shammi :
+   * There seemed to be a miscalculation with the menus initially
+   * Therefore I moved the recalculation stuff before the clearing.
+   */
+
+  /*
+    This might be a bit redundant - but it's too hard to keep
+    track of changing abox sizes when daughter objects are
+    changing sizes.
+  */
+
+  recalc_bbox();
+  x -= abox.min[0] ;
+  y -= abox.min[1] ;
+
+  /*
+   * June 17th, 1998, Shammi :
+   * Also clear the menu when the dragging the mouse and not hit.
+   */
+
+  if (   updown == active_mouse_edge || active_mouse_edge == PU_UP_AND_DOWN ||
+       ( updown == PU_DRAG && !hit ) )
+  {
+
+    /* June 17th, 1998, Shammi :
+     * Do not hide the menu if mouse is dragged out
+     */
+
+    if ( updown != PU_DRAG )
+      hide () ;
+
+    /* Turn everything off ready for next time. */
+
+    /* June 17th, 1998, Shammi:
+     * Make sure we check for a hit, if the mouse is moved
+     * out of the menu.
+     */
+
+    for ( puObject *bo = dlist ; bo != NULL ; bo = bo->next )
+    {
+      if ( ! hit )
+	bo -> checkHit ( button, updown, x , y ) ;
+
+      bo -> clrValue () ;
+    }
+  }
+
+  if ( ! hit )
+    return FALSE ;
+
+  puObject *bo ;
+  
+  /*
+    We have to walk the list backwards to ensure that
+    the click order is the same as the DRAW order.
+  */
+
+  /* June 17th, 1998, Shammi :
+   * If the mouse is dragged and the menuItem is not hit, 
+   * clear it
+   */
+
+  for ( bo = dlist ; bo->next != NULL ; bo = bo->next )
+    if ( updown == PU_DRAG && ! bo -> checkHit ( button, updown, x, y ) )
+      bo -> clrValue () ;
+
+    /* Find the last object in our list. */ ;
+
+  for ( ; bo != NULL ; bo = bo->prev )
+    if ( bo -> checkHit ( button, updown, x, y ) )
+      return TRUE ;
+
+  return FALSE ;
+}
+
+
@@ -0,0 +1,107 @@
+
+#include "puLocal.h"
+
+void puSlider::draw ( int dx, int dy )
+{
+  if ( !visible ) return ;
+
+  abox . draw ( dx, dy,
+                (style==PUSTYLE_BEVELLED||
+                 style==PUSTYLE_SHADED) ? -PUSTYLE_BOXED : -style,
+                colour, FALSE ) ;
+
+  int sd, od ;
+
+  if ( isVertical() ) { sd = 1 ; od = 0 ; } else { sd = 0 ; od = 1 ; }
+
+  int sz = abox.max [sd] - abox.min [sd] ;
+
+  float val ;
+
+  getValue ( & val ) ;
+
+  if ( val < 0.0f ) val = 0.0f ;
+  if ( val > 1.0f ) val = 1.0f ;
+
+  val *= (float) sz * (1.0f - slider_fraction) ;
+
+  puBox bx ;
+    
+  bx . min [ sd ] = abox . min [ sd ] + (int) val ;
+  bx . max [ sd ] = (int) ( (float) bx . min [ sd ] + (float) sz * slider_fraction ) ;
+  bx . min [ od ] = abox . min [ od ] + 2 ;
+  bx . max [ od ] = abox . max [ od ] - 2 ;
+
+  bx . draw ( dx, dy, PUSTYLE_SMALL_SHADED, colour, FALSE ) ;
+
+  /* If greyed out then halve the opacity when drawing the label and legend */
+
+  if ( active )
+    glColor4fv ( colour [ PUCOL_LEGEND ] ) ;
+  else
+    glColor4f ( colour [ PUCOL_LEGEND ][0],
+                colour [ PUCOL_LEGEND ][1],
+                colour [ PUCOL_LEGEND ][2],
+                colour [ PUCOL_LEGEND ][3] / 2.0f ) ; /* 50% more transparent */
+
+  int xx = ( abox.max[0] - abox.min[0] - puGetStringWidth(legendFont,legend) ) / 2 ;
+  int yy = ( abox.max[1] - abox.min[1] - puGetStringHeight(legendFont) ) / 2 ;
+
+  puDrawString ( legendFont, legend,
+                  dx + abox.min[0] + xx,
+                  dy + abox.min[1] + yy ) ;
+
+  draw_label ( dx, dy ) ;
+}
+
+
+void puSlider::doHit ( int button, int updown, int x, int y )
+{
+  if ( button == PU_LEFT_BUTTON )
+  {
+    int sd = isVertical() ;
+    int sz = abox.max [sd] - abox.min [sd] ;
+    int coord = isVertical() ? y : x ;
+
+    float next_value ;
+
+    if ( sz == 0 )
+      next_value = 0.5f ;
+    else
+    {
+      next_value = ( (float)coord - (float)abox.min[sd] - (float)sz * slider_fraction / 2.0f ) /
+                   ( (float) sz * (1.0f - slider_fraction) ) ;
+    }
+
+    next_value = (next_value < 0.0f) ? 0.0f : (next_value > 1.0) ? 1.0f : next_value ;
+
+    setValue ( next_value ) ;
+
+    switch ( cb_mode )
+    {
+      case PUSLIDER_CLICK :
+        if ( updown == active_mouse_edge )
+        {
+	  last_cb_value = next_value ;
+	  invokeCallback () ;
+        }
+        break ;
+
+      case PUSLIDER_DELTA :
+        if ( fabs ( last_cb_value - next_value ) >= cb_delta )
+        {
+	  last_cb_value = next_value ;
+	  invokeCallback () ;
+        }
+        break ;
+
+      case PUSLIDER_ALWAYS :
+      default :
+        last_cb_value = next_value ;
+        invokeCallback () ;
+        break ;
+    }
+  }
+}
+
+
@@ -0,0 +1,8 @@
+
+#include "puLocal.h"
+
+void puText::draw ( int dx, int dy )
+{
+  draw_label ( dx, dy ) ;
+}
+
@@ -0,0 +1,13 @@
+bin_PROGRAMS = testserial
+
+noinst_LIBRARIES = libSerial.a
+
+libSerial_a_SOURCES = serial.cxx serial.hxx
+
+testserial_SOURCES = testserial.cxx
+
+testserial_LDADD = \
+	$(top_builddir)/Lib/Serial/libSerial.a \
+	$(top_builddir)/Lib/Debug/libDebug.a
+
+INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib
@@ -0,0 +1,381 @@
+// serial.cxx -- Unix serial I/O support
+//
+// Written by Curtis Olson, started November 1998.
+//
+// Copyright (C) 1998  Curtis L. Olson - curt@flightgear.org
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "Include/compiler.h"
+#ifdef FG_HAVE_STD_INCLUDE
+#  include <cerrno>
+#else
+#  include <errno.h>
+#endif
+
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+  // maybe include something???
+#else
+#  include <termios.h>
+#  include <sys/types.h>
+#  include <sys/stat.h>
+#  include <fcntl.h>
+#  include <unistd.h>
+#endif
+
+#include <Debug/logstream.hxx>
+
+#include "serial.hxx"
+
+
+fgSERIAL::fgSERIAL()
+    : dev_open(false)
+{
+    // empty
+}
+
+fgSERIAL::fgSERIAL(const string& device, int baud) {
+    open_port(device);
+    
+    if ( dev_open ) {
+	set_baud(baud);
+    }
+}
+
+fgSERIAL::~fgSERIAL() {
+    // closing the port here screws us up because if we would even so
+    // much as make a copy of an fgSERIAL object and then delete it,
+    // the file descriptor gets closed.  Doh!!!
+}
+
+bool fgSERIAL::open_port(const string& device) {
+
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+
+    fd = CreateFile( device.c_str(),
+        GENERIC_READ | GENERIC_WRITE,
+        0, // dwShareMode
+        NULL, // lpSecurityAttributes
+        OPEN_EXISTING,
+        FILE_FLAG_OVERLAPPED,
+        NULL );
+    if ( fd == INVALID_HANDLE_VALUE )
+    {
+        LPVOID lpMsgBuf;
+        FormatMessage(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+            FORMAT_MESSAGE_FROM_SYSTEM | 
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL,
+            GetLastError(),
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+            (LPTSTR) &lpMsgBuf,
+            0,
+            NULL );
+
+        FG_LOG( FG_SERIAL, FG_ALERT, "Error opening serial device \"" 
+            << device << "\" " << (const char*) lpMsgBuf );
+        LocalFree( lpMsgBuf );
+        return false;
+    }
+
+    dev_open = true;
+    return true;
+
+#else
+
+    struct termios config;
+
+    fd = open(device.c_str(), O_RDWR | O_NONBLOCK);
+    cout << "Serial fd created = " << fd << endl;
+
+    if ( fd  == -1 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Cannot open " << device
+		<< " for serial I/O" );
+	return false;
+    } else {
+	dev_open = true;
+    }
+
+    // set required port parameters 
+    if ( tcgetattr( fd, &config ) != 0 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Unable to poll port settings" );
+	return false;
+    }
+
+    // cfmakeraw( &config );
+
+    // cout << "config.c_iflag = " << config.c_iflag << endl;
+
+    // software flow control on
+    config.c_iflag |= IXON;
+    // config.c_iflag |= IXOFF;
+
+    // config.c_cflag |= CLOCAL;
+
+#if ! defined( sgi )    
+    // disable hardware flow control
+    config.c_cflag &= ~(CRTSCTS);
+#endif
+
+    // cout << "config.c_iflag = " << config.c_iflag << endl;
+
+    if ( tcsetattr( fd, TCSANOW, &config ) != 0 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Unable to update port settings" );
+	return false;
+    }
+
+    return true;
+#endif
+}
+
+
+bool fgSERIAL::close_port() {
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+    CloseHandle( fd );
+#else
+    close(fd);
+#endif
+
+    return true;
+}
+
+
+bool fgSERIAL::set_baud(int baud) {
+
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+
+    return true;
+
+#else
+
+    struct termios config;
+    speed_t speed = B9600;
+
+    if ( tcgetattr( fd, &config ) != 0 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Unable to poll port settings" );
+	return false;
+    }
+
+    if ( baud == 300 ) {
+	speed = B300;
+    } else if ( baud == 1200 ) {
+	speed = B1200;
+    } else if ( baud == 2400 ) {
+	speed = B2400;
+    } else if ( baud == 4800 ) {
+	speed = B4800;
+    } else if ( baud == 9600 ) {
+	speed = B9600;
+    } else if ( baud == 19200 ) {
+	speed = B19200;
+    } else if ( baud == 38400 ) {
+	speed = B38400;
+    } else if ( baud == 57600 ) {
+	speed = B57600;
+    } else if ( baud == 115200 ) {
+	speed = B115200;
+#if defined( linux ) || defined( __FreeBSD__ )
+    } else if ( baud == 230400 ) {
+	speed = B230400;
+#endif
+    } else {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Unsupported baud rate " << baud );
+	return false;
+    }
+
+    if ( cfsetispeed( &config, speed ) != 0 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Problem setting input baud rate" );
+	return false;
+    }
+
+    if ( cfsetospeed( &config, speed ) != 0 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Problem setting output baud rate" );
+	return false;
+    }
+
+    if ( tcsetattr( fd, TCSANOW, &config ) != 0 ) {
+	FG_LOG( FG_SERIAL, FG_ALERT, "Unable to update port settings" );
+	return false;
+    }
+
+    return true;
+
+#endif
+
+}
+
+string fgSERIAL::read_port() {
+
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+
+    string result = "";
+    return result;
+
+#else
+
+    const int max_count = 1024;
+    char buffer[max_count+1];
+    int count;
+    string result;
+
+    count = read(fd, buffer, max_count);
+    // cout << "read " << count << " bytes" << endl;
+
+    if ( count < 0 ) {
+	// error condition
+	if ( errno != EAGAIN ) {
+	    FG_LOG( FG_SERIAL, FG_ALERT, 
+		    "Serial I/O on read, error number = " << errno );
+	}
+
+	return "";
+    } else {
+	buffer[count] = '\0';
+	result = buffer;
+
+	return result;
+    }
+
+#endif
+
+}
+
+int fgSERIAL::write_port(const string& value) {
+
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+
+    LPCVOID lpBuffer = value.c_str();
+    DWORD nNumberOfBytesToWrite = value.length();
+    DWORD lpNumberOfBytesWritten;
+    OVERLAPPED lpOverlapped;
+
+    if ( WriteFile( fd,
+        lpBuffer,
+        nNumberOfBytesToWrite,
+        &lpNumberOfBytesWritten,
+        &lpOverlapped ) == 0 )
+    {
+        LPVOID lpMsgBuf;
+        FormatMessage(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+            FORMAT_MESSAGE_FROM_SYSTEM | 
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL,
+            GetLastError(),
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+            (LPTSTR) &lpMsgBuf,
+            0,
+            NULL );
+
+        FG_LOG( FG_SERIAL, FG_ALERT, "Serial I/O write error: " 
+             << (const char*) lpMsgBuf );
+        LocalFree( lpMsgBuf );
+        return int(lpNumberOfBytesWritten);
+    }
+
+    return int(lpNumberOfBytesWritten);
+
+#else
+
+    static bool error = false;
+    int count;
+
+    if ( error ) {
+	// attempt some sort of error recovery
+	count = write(fd, "\n", 1);
+	if ( count == 1 ) {
+	    // cout << "Serial error recover successful!\n";
+	    error = false;
+	} else {
+	    return 0;
+	}
+    }
+
+    count = write(fd, value.c_str(), value.length());
+    // cout << "write '" << value << "'  " << count << " bytes" << endl;
+
+    if ( (int)count == (int)value.length() ) {
+	error = false;
+    } else {
+	error = true;
+	if ( errno == EAGAIN ) {
+	    // ok ... in our context we don't really care if we can't
+	    // write a string, we'll just get it the next time around
+	} else {
+	    FG_LOG( FG_SERIAL, FG_ALERT,
+		    "Serial I/O on write, error number = " << errno );
+	}
+    }
+
+    return count;
+
+#endif
+
+}
+
+
+// $Log$
+// Revision 1.9  1999/02/02 20:13:23  curt
+// MSVC++ portability changes by Bernie Bright:
+//
+// Lib/Serial/serial.[ch]xx: Initial Windows support - incomplete.
+// Simulator/Astro/stars.cxx: typo? included <stdio> instead of <cstdio>
+// Simulator/Cockpit/hud.cxx: Added Standard headers
+// Simulator/Cockpit/panel.cxx: Redefinition of default parameter
+// Simulator/Flight/flight.cxx: Replaced cout with FG_LOG.  Deleted <stdio.h>
+// Simulator/Main/fg_init.cxx:
+// Simulator/Main/GLUTmain.cxx:
+// Simulator/Main/options.hxx: Shuffled <fg_serial.hxx> dependency
+// Simulator/Objects/material.hxx:
+// Simulator/Time/timestamp.hxx: VC++ friend kludge
+// Simulator/Scenery/tile.[ch]xx: Fixed using std::X declarations
+// Simulator/Main/views.hxx: Added a constant
+//
+// Revision 1.8  1999/01/20 13:42:21  curt
+// Tweaked FDM interface.
+// Testing check sum support for NMEA serial output.
+//
+// Revision 1.7  1998/12/04 01:24:35  curt
+// Tweak for SGI portability.
+//
+// Revision 1.6  1998/11/30 17:15:29  curt
+// Having the class destructor close the fd was a bad idea ... especially if you
+// ever make a copy of the instance and then subsequently destroy either.
+// close_port() is now a separate member function.
+//
+// Revision 1.5  1998/11/25 01:33:23  curt
+// Remove call to cfmakeraw()
+//
+// Revision 1.4  1998/11/23 21:47:00  curt
+// Cygnus tools compatibility tweaks.
+//
+// Revision 1.3  1998/11/19 13:52:54  curt
+// port configuration tweaks & experiments.
+//
+// Revision 1.2  1998/11/19 03:35:43  curt
+// Updates ...
+//
+// Revision 1.1  1998/11/16 13:53:02  curt
+// Initial revision.
+//
@@ -0,0 +1,112 @@
+// serial.hxx -- Unix serial I/O support
+//
+// Written by Curtis Olson, started November 1998.
+//
+// Copyright (C) 1998  Curtis L. Olson - curt@flightgear.org
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
+
+
+#ifndef _SERIAL_HXX
+#define _SERIAL_HXX
+
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+#  include <windows.h>
+#endif
+
+#include <Include/compiler.h>
+#include STL_STRING
+FG_USING_STD(string);
+
+// if someone know how to do this all with C++ streams let me know
+// #include <stdio.h>
+
+
+class fgSERIAL
+{
+#if defined( WIN32 ) && !defined( __CYGWIN__) && !defined( __CYGWIN32__ )
+    typedef HANDLE fd_type;
+#else
+    typedef int fd_type;
+#endif
+
+private:
+
+    fd_type fd;
+    bool dev_open;
+
+public:
+
+    fgSERIAL();
+    fgSERIAL(const string& device, int baud);
+
+    ~fgSERIAL();
+
+    bool open_port(const string& device);
+    bool close_port();
+    bool set_baud(int baud);
+    string read_port();
+    int write_port(const string& value);
+
+    inline bool is_enabled() { return dev_open; }
+};
+
+
+#endif // _SERIAL_HXX
+
+
+// $Log$
+// Revision 1.5  1999/03/02 01:01:58  curt
+// Tweaks for compiling with native SGI compilers.
+//
+// Revision 1.4  1999/02/26 22:08:13  curt
+// Added initial support for native SGI compilers.
+//
+// Revision 1.3  1999/02/02 20:13:24  curt
+// MSVC++ portability changes by Bernie Bright:
+//
+// Lib/Serial/serial.[ch]xx: Initial Windows support - incomplete.
+// Simulator/Astro/stars.cxx: typo? included <stdio> instead of <cstdio>
+// Simulator/Cockpit/hud.cxx: Added Standard headers
+// Simulator/Cockpit/panel.cxx: Redefinition of default parameter
+// Simulator/Flight/flight.cxx: Replaced cout with FG_LOG.  Deleted <stdio.h>
+// Simulator/Main/fg_init.cxx:
+// Simulator/Main/GLUTmain.cxx:
+// Simulator/Main/options.hxx: Shuffled <fg_serial.hxx> dependency
+// Simulator/Objects/material.hxx:
+// Simulator/Time/timestamp.hxx: VC++ friend kludge
+// Simulator/Scenery/tile.[ch]xx: Fixed using std::X declarations
+// Simulator/Main/views.hxx: Added a constant
+//
+// Revision 1.2  1998/11/30 17:15:30  curt
+// Having the class destructor close the fd was a bad idea ... especially if you
+// ever make a copy of the instance and then subsequently destroy either.
+// close_port() is now a separate member function.
+//
+// Revision 1.1  1998/11/16 13:53:02  curt
+// Initial revision.
+//
@@ -0,0 +1,30 @@
+#include <string>
+
+#include <Debug/logstream.hxx>
+
+#include "serial.hxx"
+
+main () {
+    fgSERIAL port;
+    string value;
+    bool result;
+
+    fglog().setLogLevels( FG_ALL, FG_INFO );
+
+    cout << "start of main" << endl;
+
+    result = port.open_port("/dev/ttyS1");
+    cout << "opened port, result = " << result << endl;
+
+    result = port.set_baud(4800);
+    cout << "set baud, result = " << result << endl;
+
+    port.write_port("ATDT 626-9800\n");
+
+    while ( true ) {
+	value = port.read_port();
+	if ( value.length() ) {
+	    cout << "-> " << value << endl;
+	}
+    }
+}
@@ -0,0 +1,5 @@
+lib_LIBRARIES = libXGL.a
+
+libXGL_a_SOURCES = xgl.c xgl.h xglUtils.c
+
+INCLUDES += -I$(top_builddir) -I$(top_builddir)/Simulator
@@ -0,0 +1,837 @@
+#ifndef _XGL_H
+#define _XGL_H
+
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <stdio.h>
+
+
+#ifdef __cplusplus                                                          
+extern "C" {                            
+#endif                                   
+
+
+/* xgl Utilities */
+
+extern FILE *xglTraceFd ;
+
+int       xglTraceIsEnabled   ( char *gl_function_name ) ;
+int       xglExecuteIsEnabled ( char *gl_function_name ) ;
+char     *xglExpandGLenum     ( GLenum x ) ;
+
+GLdouble *xglBuild1dv  ( GLdouble v ) ;
+GLfloat  *xglBuild1fv  ( GLfloat  v ) ;
+GLbyte   *xglBuild1bv  ( GLbyte   v ) ;
+GLint    *xglBuild1iv  ( GLint    v ) ;
+GLshort  *xglBuild1sv  ( GLshort  v ) ;
+GLubyte  *xglBuild1ubv ( GLubyte  v ) ;
+GLuint   *xglBuild1uiv ( GLuint   v ) ;
+GLushort *xglBuild1usv ( GLushort v ) ;
+
+GLdouble *xglBuild2dv  ( GLdouble v0, GLdouble v1 ) ;
+GLfloat  *xglBuild2fv  ( GLfloat  v0, GLfloat  v1 ) ;
+GLbyte   *xglBuild2bv  ( GLbyte   v0, GLbyte   v1 ) ;
+GLint    *xglBuild2iv  ( GLint    v0, GLint    v1 ) ;
+GLshort  *xglBuild2sv  ( GLshort  v0, GLshort  v1 ) ;
+GLubyte  *xglBuild2ubv ( GLubyte  v0, GLubyte  v1 ) ;
+GLuint   *xglBuild2uiv ( GLuint   v0, GLuint   v1 ) ;
+GLushort *xglBuild2usv ( GLushort v0, GLushort v1 ) ;
+
+GLdouble *xglBuild3dv  ( GLdouble v0, GLdouble v1, GLdouble v2 ) ;
+GLfloat  *xglBuild3fv  ( GLfloat  v0, GLfloat  v1, GLfloat  v2 ) ;
+GLbyte   *xglBuild3bv  ( GLbyte   v0, GLbyte   v1, GLbyte   v2 ) ;
+GLint    *xglBuild3iv  ( GLint    v0, GLint    v1, GLint    v2 ) ;
+GLshort  *xglBuild3sv  ( GLshort  v0, GLshort  v1, GLshort  v2 ) ;
+GLubyte  *xglBuild3ubv ( GLubyte  v0, GLubyte  v1, GLubyte  v2 ) ;
+GLuint   *xglBuild3uiv ( GLuint   v0, GLuint   v1, GLuint   v2 ) ;
+GLushort *xglBuild3usv ( GLushort v0, GLushort v1, GLushort v2 ) ;
+
+GLdouble *xglBuild4dv  ( GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) ;
+GLfloat  *xglBuild4fv  ( GLfloat  v0, GLfloat  v1, GLfloat  v2, GLfloat  v3 ) ;
+GLbyte   *xglBuild4bv  ( GLbyte   v0, GLbyte   v1, GLbyte   v2, GLbyte   v3 ) ;
+GLint    *xglBuild4iv  ( GLint    v0, GLint    v1, GLint    v2, GLint    v3 ) ;
+GLshort  *xglBuild4sv  ( GLshort  v0, GLshort  v1, GLshort  v2, GLshort  v3 ) ;
+GLubyte  *xglBuild4ubv ( GLubyte  v0, GLubyte  v1, GLubyte  v2, GLubyte  v3 ) ;
+GLuint   *xglBuild4uiv ( GLuint   v0, GLuint   v1, GLuint   v2, GLuint   v3 ) ;
+GLushort *xglBuild4usv ( GLushort v0, GLushort v1, GLushort v2, GLushort v3 ) ;
+
+GLfloat  *xglBuildMatrixf ( GLfloat m0 , GLfloat m1 , GLfloat m2 , GLfloat m3 ,
+                            GLfloat m4 , GLfloat m5 , GLfloat m6 , GLfloat m7 ,
+                            GLfloat m8 , GLfloat m9 , GLfloat m10, GLfloat m11,
+                            GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15 ) ;
+
+GLdouble *xglBuildMatrixd ( GLdouble m0 , GLdouble m1 , GLdouble m2 , GLdouble m3 ,
+                            GLdouble m4 , GLdouble m5 , GLdouble m6 , GLdouble m7 ,
+                            GLdouble m8 , GLdouble m9 , GLdouble m10, GLdouble m11,
+                            GLdouble m12, GLdouble m13, GLdouble m14, GLdouble m15 ) ;
+
+/*
+  Conditionally compile all 'xgl' calls into standard 'gl' calls...
+
+  OR
+
+  Declare all possible 'xgl' calls as 'extern'.
+*/
+
+#ifndef XGL_TRACE
+
+#define xglAccum		glAccum	
+#define xglAlphaFunc		glAlphaFunc	
+#ifdef GL_EXT_vertex_array
+#define xglArrayElementEXT	glArrayElementEXT	
+#endif
+#define xglBegin		glBegin	
+#define xglBitmap		glBitmap	
+#ifdef GL_EXT_blend_color
+#define xglBlendColorEXT	glBlendColorEXT	
+#endif
+#ifdef GL_EXT_blend_minmax
+#define xglBlendEquationEXT	glBlendEquationEXT	
+#endif
+#define xglBlendFunc		glBlendFunc	
+#define xglCallList		glCallList	
+#define xglCallLists		glCallLists	
+#define xglClear		glClear	
+#define xglClearAccum		glClearAccum	
+#define xglClearColor		glClearColor	
+#define xglClearDepth		glClearDepth	
+#define xglClearIndex		glClearIndex	
+#define xglClearStencil		glClearStencil	
+#define xglClipPlane		glClipPlane	
+#define xglColor3b		glColor3b	
+#define xglColor3bv		glColor3bv	
+#define xglColor3d		glColor3d	
+#define xglColor3dv		glColor3dv	
+#define xglColor3f		glColor3f	
+#define xglColor3fv		glColor3fv	
+#define xglColor3i		glColor3i	
+#define xglColor3iv		glColor3iv	
+#define xglColor3s		glColor3s	
+#define xglColor3sv		glColor3sv	
+#define xglColor3ub		glColor3ub	
+#define xglColor3ubv		glColor3ubv	
+#define xglColor3ui		glColor3ui	
+#define xglColor3uiv		glColor3uiv	
+#define xglColor3us		glColor3us	
+#define xglColor3usv		glColor3usv	
+#define xglColor4b		glColor4b	
+#define xglColor4bv		glColor4bv	
+#define xglColor4d		glColor4d	
+#define xglColor4dv		glColor4dv	
+#define xglColor4f		glColor4f	
+#define xglColor4fv		glColor4fv	
+#define xglColor4i		glColor4i	
+#define xglColor4iv		glColor4iv	
+#define xglColor4s		glColor4s	
+#define xglColor4sv		glColor4sv	
+#define xglColor4ub		glColor4ub	
+#define xglColor4ubv		glColor4ubv	
+#define xglColor4ui		glColor4ui	
+#define xglColor4uiv		glColor4uiv	
+#define xglColor4us		glColor4us	
+#define xglColor4usv		glColor4usv	
+#define xglColorMask		glColorMask	
+#define xglColorMaterial	glColorMaterial	
+#ifdef GL_EXT_vertex_array
+#define xglColorPointerEXT	glColorPointerEXT	
+#endif
+#define xglCopyPixels		glCopyPixels	
+#define xglCullFace		glCullFace	
+#define xglDeleteLists		glDeleteLists	
+#define xglDepthFunc		glDepthFunc	
+#define xglDepthMask		glDepthMask	
+#define xglDepthRange		glDepthRange	
+#define xglDisable		glDisable	
+#ifdef GL_EXT_vertex_array
+#define xglDrawArraysEXT	glDrawArraysEXT	
+#endif
+#define xglDrawBuffer		glDrawBuffer	
+#define xglDrawPixels		glDrawPixels	
+#define xglEdgeFlag		glEdgeFlag	
+#ifdef GL_EXT_vertex_array
+#define xglEdgeFlagPointerEXT	glEdgeFlagPointerEXT	
+#endif
+#define xglEdgeFlagv		glEdgeFlagv	
+#define xglEnable		glEnable	
+#define xglEnd			glEnd	
+#define xglEndList		glEndList	
+#define xglEvalCoord1d		glEvalCoord1d	
+#define xglEvalCoord1dv		glEvalCoord1dv	
+#define xglEvalCoord1f		glEvalCoord1f	
+#define xglEvalCoord1fv		glEvalCoord1fv	
+#define xglEvalCoord2d		glEvalCoord2d	
+#define xglEvalCoord2dv		glEvalCoord2dv	
+#define xglEvalCoord2f		glEvalCoord2f	
+#define xglEvalCoord2fv		glEvalCoord2fv	
+#define xglEvalMesh1		glEvalMesh1	
+#define xglEvalMesh2		glEvalMesh2	
+#define xglEvalPoint1		glEvalPoint1	
+#define xglEvalPoint2		glEvalPoint2	
+#define xglFeedbackBuffer	glFeedbackBuffer	
+#define xglFinish		glFinish	
+#define xglFlush		glFlush	
+#define xglFogf			glFogf	
+#define xglFogfv		glFogfv	
+#define xglFogi			glFogi	
+#define xglFogiv		glFogiv	
+#define xglFrontFace		glFrontFace	
+#define xglFrustum		glFrustum	
+#define xglGenLists		glGenLists	
+#define xglGetBooleanv		glGetBooleanv	
+#define xglGetClipPlane		glGetClipPlane	
+#define xglGetDoublev		glGetDoublev	
+#define xglGetError		glGetError	
+#define xglGetFloatv		glGetFloatv	
+#define xglGetIntegerv		glGetIntegerv	
+#define xglGetLightfv		glGetLightfv	
+#define xglGetLightiv		glGetLightiv	
+#define xglGetMapdv		glGetMapdv	
+#define xglGetMapfv		glGetMapfv	
+#define xglGetMapiv		glGetMapiv	
+#define xglGetMaterialfv	glGetMaterialfv	
+#define xglGetMaterialiv	glGetMaterialiv	
+#define xglGetPixelMapfv	glGetPixelMapfv	
+#define xglGetPixelMapuiv	glGetPixelMapuiv	
+#define xglGetPixelMapusv	glGetPixelMapusv	
+#ifdef GL_EXT_vertex_array
+#define xglGetPointervEXT	glGetPointervEXT	
+#endif
+#define xglGetPolygonStipple	glGetPolygonStipple	
+#define xglGetString		glGetString	
+#define xglGetTexEnvfv		glGetTexEnvfv	
+#define xglGetTexEnviv		glGetTexEnviv	
+#define xglGetTexGendv		glGetTexGendv	
+#define xglGetTexGenfv		glGetTexGenfv	
+#define xglGetTexGeniv		glGetTexGeniv	
+#define xglGetTexImage		glGetTexImage	
+#define xglGetTexLevelParameterfv glGetTexLevelParameterfv	
+#define xglGetTexLevelParameteriv glGetTexLevelParameteriv	
+#define xglGetTexParameterfv	glGetTexParameterfv	
+#define xglGetTexParameteriv	glGetTexParameteriv	
+#define xglHint			glHint	
+#define xglIndexMask		glIndexMask	
+#ifdef GL_EXT_vertex_array
+#define xglIndexPointerEXT	glIndexPointerEXT	
+#endif
+#define xglIndexd		glIndexd	
+#define xglIndexdv		glIndexdv	
+#define xglIndexf		glIndexf	
+#define xglIndexfv		glIndexfv	
+#define xglIndexi		glIndexi	
+#define xglIndexiv		glIndexiv	
+#define xglIndexs		glIndexs	
+#define xglIndexsv		glIndexsv	
+#define xglInitNames		glInitNames	
+#define xglIsEnabled		glIsEnabled	
+#define xglIsList		glIsList	
+#define xglLightModelf		glLightModelf	
+#define xglLightModelfv		glLightModelfv	
+#define xglLightModeli		glLightModeli	
+#define xglLightModeliv		glLightModeliv	
+#define xglLightf		glLightf	
+#define xglLightfv		glLightfv	
+#define xglLighti		glLighti	
+#define xglLightiv		glLightiv	
+#define xglLineStipple		glLineStipple	
+#define xglLineWidth		glLineWidth	
+#define xglListBase		glListBase	
+#define xglLoadIdentity		glLoadIdentity	
+#define xglLoadMatrixd		glLoadMatrixd	
+#define xglLoadMatrixf		glLoadMatrixf	
+#define xglLoadName		glLoadName	
+#define xglLogicOp		glLogicOp	
+#define xglMap1d		glMap1d	
+#define xglMap1f		glMap1f	
+#define xglMap2d		glMap2d	
+#define xglMap2f		glMap2f	
+#define xglMapGrid1d		glMapGrid1d	
+#define xglMapGrid1f		glMapGrid1f	
+#define xglMapGrid2d		glMapGrid2d	
+#define xglMapGrid2f		glMapGrid2f	
+#define xglMaterialf		glMaterialf	
+#define xglMaterialfv		glMaterialfv	
+#define xglMateriali		glMateriali	
+#define xglMaterialiv		glMaterialiv	
+#define xglMatrixMode		glMatrixMode	
+#define xglMultMatrixd		glMultMatrixd	
+#define xglMultMatrixf		glMultMatrixf	
+#define xglNewList		glNewList	
+#define xglNormal3b		glNormal3b	
+#define xglNormal3bv		glNormal3bv	
+#define xglNormal3d		glNormal3d	
+#define xglNormal3dv		glNormal3dv	
+#define xglNormal3f		glNormal3f	
+#ifdef DEBUGGING_NORMALS
+#define xglNormal3fv(f)		{\
+float ff = (f)[0]*(f)[0]+(f)[1]*(f)[1]+(f)[2]*(f)[2];\
+if ( ff < 0.9 || ff > 1.1 )\
+{\
+fprintf(stderr,"glNormal3fv Overflow: %f, %f, %f -> %f [%s,%s,%s]\n",\
+(f)[0],(f)[1],(f)[2],ff,str1,str2,str3);\
+normal_bombed = 1 ;\
+}\
+glNormal3fv(f);\
+}
+#else
+#define xglNormal3fv   		glNormal3fv
+#endif
+#define xglNormal3i		glNormal3i	
+#define xglNormal3iv		glNormal3iv	
+#define xglNormal3s		glNormal3s	
+#define xglNormal3sv		glNormal3sv	
+#ifdef GL_EXT_vertex_array
+#define xglNormalPointerEXT	glNormalPointerEXT	
+#endif
+#define xglOrtho		glOrtho	
+#define xglPassThrough		glPassThrough	
+#define xglPixelMapfv		glPixelMapfv	
+#define xglPixelMapuiv		glPixelMapuiv	
+#define xglPixelMapusv		glPixelMapusv	
+#define xglPixelStoref		glPixelStoref	
+#define xglPixelStorei		glPixelStorei	
+#define xglPixelTransferf	glPixelTransferf	
+#define xglPixelTransferi	glPixelTransferi	
+#define xglPixelZoom		glPixelZoom	
+#define xglPointSize		glPointSize	
+#define xglPolygonMode		glPolygonMode	
+#ifdef GL_EXT_polygon_offset
+#define xglPolygonOffsetEXT	glPolygonOffsetEXT	
+#endif
+#define xglPolygonOffset	glPolygonOffset	
+#define xglPolygonStipple	glPolygonStipple	
+#define xglPopAttrib		glPopAttrib	
+#define xglPopMatrix		glPopMatrix	
+#define xglPopName		glPopName	
+#define xglPushAttrib		glPushAttrib	
+#define xglPushMatrix		glPushMatrix	
+#define xglPushName		glPushName	
+#define xglRasterPos2d		glRasterPos2d	
+#define xglRasterPos2dv		glRasterPos2dv	
+#define xglRasterPos2f		glRasterPos2f	
+#define xglRasterPos2fv		glRasterPos2fv	
+#define xglRasterPos2i		glRasterPos2i	
+#define xglRasterPos2iv		glRasterPos2iv	
+#define xglRasterPos2s		glRasterPos2s	
+#define xglRasterPos2sv		glRasterPos2sv	
+#define xglRasterPos3d		glRasterPos3d	
+#define xglRasterPos3dv		glRasterPos3dv	
+#define xglRasterPos3f		glRasterPos3f	
+#define xglRasterPos3fv		glRasterPos3fv	
+#define xglRasterPos3i		glRasterPos3i	
+#define xglRasterPos3iv		glRasterPos3iv	
+#define xglRasterPos3s		glRasterPos3s	
+#define xglRasterPos3sv		glRasterPos3sv	
+#define xglRasterPos4d		glRasterPos4d	
+#define xglRasterPos4dv		glRasterPos4dv	
+#define xglRasterPos4f		glRasterPos4f	
+#define xglRasterPos4fv		glRasterPos4fv	
+#define xglRasterPos4i		glRasterPos4i	
+#define xglRasterPos4iv		glRasterPos4iv	
+#define xglRasterPos4s		glRasterPos4s	
+#define xglRasterPos4sv		glRasterPos4sv	
+#define xglReadBuffer		glReadBuffer	
+#define xglReadPixels		glReadPixels	
+#define xglRectd		glRectd	
+#define xglRectdv		glRectdv	
+#define xglRectf		glRectf	
+#define xglRectfv		glRectfv	
+#define xglRecti		glRecti	
+#define xglRectiv		glRectiv	
+#define xglRects		glRects	
+#define xglRectsv		glRectsv	
+#define xglRenderMode		glRenderMode	
+#define xglRotated		glRotated	
+#define xglRotatef		glRotatef	
+#define xglScaled		glScaled	
+#define xglScalef		glScalef	
+#define xglScissor		glScissor	
+#define xglSelectBuffer		glSelectBuffer	
+#define xglShadeModel		glShadeModel	
+#define xglStencilFunc		glStencilFunc	
+#define xglStencilMask		glStencilMask	
+#define xglStencilOp		glStencilOp	
+#define xglTexCoord1d		glTexCoord1d	
+#define xglTexCoord1dv		glTexCoord1dv	
+#define xglTexCoord1f		glTexCoord1f	
+#define xglTexCoord1fv		glTexCoord1fv	
+#define xglTexCoord1i		glTexCoord1i	
+#define xglTexCoord1iv		glTexCoord1iv	
+#define xglTexCoord1s		glTexCoord1s	
+#define xglTexCoord1sv		glTexCoord1sv	
+#define xglTexCoord2d		glTexCoord2d	
+#define xglTexCoord2dv		glTexCoord2dv	
+#define xglTexCoord2f		glTexCoord2f	
+#define xglTexCoord2fv		glTexCoord2fv	
+#define xglTexCoord2i		glTexCoord2i	
+#define xglTexCoord2iv		glTexCoord2iv	
+#define xglTexCoord2s		glTexCoord2s	
+#define xglTexCoord2sv		glTexCoord2sv	
+#define xglTexCoord3d		glTexCoord3d	
+#define xglTexCoord3dv		glTexCoord3dv	
+#define xglTexCoord3f		glTexCoord3f	
+#define xglTexCoord3fv		glTexCoord3fv	
+#define xglTexCoord3i		glTexCoord3i	
+#define xglTexCoord3iv		glTexCoord3iv	
+#define xglTexCoord3s		glTexCoord3s	
+#define xglTexCoord3sv		glTexCoord3sv	
+#define xglTexCoord4d		glTexCoord4d	
+#define xglTexCoord4dv		glTexCoord4dv	
+#define xglTexCoord4f		glTexCoord4f	
+#define xglTexCoord4fv		glTexCoord4fv	
+#define xglTexCoord4i		glTexCoord4i	
+#define xglTexCoord4iv		glTexCoord4iv	
+#define xglTexCoord4s		glTexCoord4s	
+#define xglTexCoord4sv		glTexCoord4sv	
+#ifdef GL_EXT_vertex_array
+#define xglTexCoordPointerEXT	glTexCoordPointerEXT	
+#endif
+#define xglTexEnvf		glTexEnvf	
+#define xglTexEnvfv		glTexEnvfv	
+#define xglTexEnvi		glTexEnvi	
+#define xglTexEnviv		glTexEnviv	
+#define xglTexGend		glTexGend	
+#define xglTexGendv		glTexGendv	
+#define xglTexGenf		glTexGenf	
+#define xglTexGenfv		glTexGenfv	
+#define xglTexGeni		glTexGeni	
+#define xglTexGeniv		glTexGeniv	
+#define xglTexImage1D		glTexImage1D	
+#define xglTexImage2D		glTexImage2D	
+#define xglTexParameterf	glTexParameterf	
+#define xglTexParameterfv	glTexParameterfv	
+#define xglTexParameteri	glTexParameteri	
+#define xglTexParameteriv	glTexParameteriv	
+#define xglTranslated		glTranslated	
+#define xglTranslatef		glTranslatef	
+#define xglVertex2d		glVertex2d	
+#define xglVertex2dv		glVertex2dv	
+#define xglVertex2f		glVertex2f	
+#define xglVertex2fv		glVertex2fv	
+#define xglVertex2i		glVertex2i	
+#define xglVertex2iv		glVertex2iv	
+#define xglVertex2s		glVertex2s	
+#define xglVertex2sv		glVertex2sv	
+#define xglVertex3d		glVertex3d	
+#define xglVertex3dv		glVertex3dv	
+#define xglVertex3f		glVertex3f	
+#define xglVertex3fv		glVertex3fv	
+#define xglVertex3i		glVertex3i	
+#define xglVertex3iv		glVertex3iv	
+#define xglVertex3s		glVertex3s	
+#define xglVertex3sv		glVertex3sv	
+#define xglVertex4d		glVertex4d	
+#define xglVertex4dv		glVertex4dv	
+#define xglVertex4f		glVertex4f	
+#define xglVertex4fv		glVertex4fv	
+#define xglVertex4i		glVertex4i	
+#define xglVertex4iv		glVertex4iv	
+#define xglVertex4s		glVertex4s	
+#define xglVertex4sv		glVertex4sv	
+#ifdef GL_EXT_vertex_array
+#define xglVertexPointerEXT	glVertexPointerEXT	
+#endif
+#define xglViewport		glViewport	
+
+#ifdef GL_VERSION_1_1
+#define xglAreTexturesResident	  glAreTexturesResident
+#define xglIsTexture		  glIsTexture
+#define xglBindTexture		  glBindTexture
+#define xglDeleteTextures	  glDeleteTextures
+#define xglGenTextures		  glGenTextures
+#define xglPrioritizeTextures	  glPrioritizeTextures
+#endif
+
+#ifdef GL_EXT_texture_object
+#define xglAreTexturesResidentEXT glAreTexturesResidentEXT
+#define xglIsTextureEXT		  glIsTextureEXT
+#define xglBindTextureEXT	  glBindTextureEXT
+#define xglDeleteTexturesEXT	  glDeleteTexturesEXT
+#define xglGenTexturesEXT	  glGenTexturesEXT
+#define xglPrioritizeTexturesEXT  glPrioritizeTexturesEXT
+#endif
+
+#define xglutAddMenuEntry       glutAddMenuEntry
+#define xglutAttachMenu         glutAttachMenu
+#define xglutCreateMenu         glutCreateMenu
+#define xglutCreateWindow       glutCreateWindow
+#define xglutDisplayFunc        glutDisplayFunc
+#define xglutIdleFunc           glutIdleFunc
+#define xglutInit               glutInit
+#define xglutInitDisplayMode    glutInitDisplayMode
+#define xglutInitWindowPosition glutInitWindowPosition
+#define xglutInitWindowSize     glutInitWindowSize
+#define xglutKeyboardFunc       glutKeyboardFunc
+#define xglutMainLoopUpdate     glutMainLoopUpdate
+#define xglutPostRedisplay      glutPostRedisplay
+#define xglutPreMainLoop        glutPreMainLoop
+#define xglutReshapeFunc        glutReshapeFunc
+#define xglutSwapBuffers        glutSwapBuffers
+
+#else
+
+GLboolean xglIsEnabled  ( GLenum cap ) ; 
+GLboolean xglIsList     ( GLuint list ) ; 
+GLenum    xglGetError   () ; 
+GLint     xglRenderMode ( GLenum mode ) ; 
+GLuint    xglGenLists   ( GLsizei range ) ; 
+const GLubyte  *xglGetString  ( GLenum name ) ; 
+
+void xglAccum		( GLenum op, GLfloat value ) ;
+void xglAlphaFunc	( GLenum func, GLclampf ref ) ;
+void xglArrayElementEXT	( GLint i ) ;
+void xglBegin		( GLenum mode ) ;
+void xglBitmap		( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte *bitmap ) ;
+void xglBlendColorEXT	( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) ;
+void xglBlendEquationEXT( GLenum mode ) ;
+void xglBlendFunc	( GLenum sfactor, GLenum dfactor ) ;
+void xglCallList	( GLuint list ) ;
+void xglCallLists	( GLsizei n, GLenum type, GLvoid *lists ) ;
+void xglClear		( GLbitfield mask ) ;
+void xglClearAccum	( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) ;
+void xglClearColor	( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) ;
+void xglClearDepth	( GLclampd depth ) ;
+void xglClearIndex	( GLfloat c ) ;
+void xglClearStencil	( GLint s ) ;
+void xglClipPlane	( GLenum plane, GLdouble *equation ) ;
+void xglColor3b		( GLbyte red, GLbyte green, GLbyte blue ) ;
+void xglColor3bv	( GLbyte *v ) ;
+void xglColor3d		( GLdouble red, GLdouble green, GLdouble blue ) ;
+void xglColor3dv	( GLdouble *v ) ;
+void xglColor3f		( GLfloat red, GLfloat green, GLfloat blue ) ;
+void xglColor3fv	( GLfloat *v ) ;
+void xglColor3i		( GLint red, GLint green, GLint blue ) ;
+void xglColor3iv	( GLint *v ) ;
+void xglColor3s		( GLshort red, GLshort green, GLshort blue ) ;
+void xglColor3sv	( GLshort *v ) ;
+void xglColor3ub	( GLubyte red, GLubyte green, GLubyte blue ) ;
+void xglColor3ubv	( GLubyte *v ) ;
+void xglColor3ui	( GLuint red, GLuint green, GLuint blue ) ;
+void xglColor3uiv	( GLuint *v ) ;
+void xglColor3us	( GLushort red, GLushort green, GLushort blue ) ;
+void xglColor3usv	( GLushort *v ) ;
+void xglColor4b		( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) ;
+void xglColor4bv	( GLbyte *v ) ;
+void xglColor4d		( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) ;
+void xglColor4dv	( GLdouble *v ) ;
+void xglColor4f		( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) ;
+void xglColor4fv	( GLfloat *v ) ;
+void xglColor4i		( GLint red, GLint green, GLint blue, GLint alpha ) ;
+void xglColor4iv	( GLint *v ) ;
+void xglColor4s		( GLshort red, GLshort green, GLshort blue, GLshort alpha ) ;
+void xglColor4sv	( GLshort *v ) ;
+void xglColor4ub	( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) ;
+void xglColor4ubv	( GLubyte *v ) ;
+void xglColor4ui	( GLuint red, GLuint green, GLuint blue, GLuint alpha ) ;
+void xglColor4uiv	( GLuint *v ) ;
+void xglColor4us	( GLushort red, GLushort green, GLushort blue, GLushort alpha ) ;
+void xglColor4usv	( GLushort *v ) ;
+void xglColorMask	( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) ;
+void xglColorMaterial	( GLenum face, GLenum mode ) ;
+void xglColorPointerEXT	( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglCopyPixels	( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) ;
+void xglCullFace	( GLenum mode ) ;
+void xglDeleteLists	( GLuint list, GLsizei range ) ;
+void xglDepthFunc	( GLenum func ) ;
+void xglDepthMask	( GLboolean flag ) ;
+void xglDepthRange	( GLclampd near_val, GLclampd far_val ) ;
+void xglDisable		( GLenum cap ) ;
+void xglDrawArraysEXT	( GLenum mode, GLint first, GLsizei count ) ;
+void xglDrawBuffer	( GLenum mode ) ;
+void xglDrawPixels	( GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglEdgeFlag	( GLboolean flag ) ;
+void xglEdgeFlagPointerEXT( GLsizei stride, GLsizei count, GLboolean *ptr ) ;
+void xglEdgeFlagv	( GLboolean *flag ) ;
+void xglEnable		( GLenum cap ) ;
+void xglEnd		() ;
+void xglEndList		() ;
+void xglEvalCoord1d	( GLdouble u ) ;
+void xglEvalCoord1dv	( GLdouble *u ) ;
+void xglEvalCoord1f	( GLfloat u ) ;
+void xglEvalCoord1fv	( GLfloat *u ) ;
+void xglEvalCoord2d	( GLdouble u, GLdouble v ) ;
+void xglEvalCoord2dv	( GLdouble *u ) ;
+void xglEvalCoord2f	( GLfloat u, GLfloat v ) ;
+void xglEvalCoord2fv	( GLfloat *u ) ;
+void xglEvalMesh1	( GLenum mode, GLint i1, GLint i2 ) ;
+void xglEvalMesh2	( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) ;
+void xglEvalPoint1	( GLint i ) ;
+void xglEvalPoint2	( GLint i, GLint j ) ;
+void xglFeedbackBuffer	( GLsizei size, GLenum type, GLfloat *buffer ) ;
+void xglFinish		() ;
+void xglFlush		() ;
+void xglFogf		( GLenum pname, GLfloat param ) ;
+void xglFogfv		( GLenum pname, GLfloat *params ) ;
+void xglFogi		( GLenum pname, GLint param ) ;
+void xglFogiv		( GLenum pname, GLint *params ) ;
+void xglFrontFace	( GLenum mode ) ;
+void xglFrustum		( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) ;
+void xglGetBooleanv	( GLenum pname, GLboolean *params ) ;
+void xglGetClipPlane	( GLenum plane, GLdouble *equation ) ;
+void xglGetDoublev	( GLenum pname, GLdouble *params ) ;
+void xglGetFloatv	( GLenum pname, GLfloat *params ) ;
+void xglGetIntegerv	( GLenum pname, GLint *params ) ;
+void xglGetLightfv	( GLenum light, GLenum pname, GLfloat *params ) ;
+void xglGetLightiv	( GLenum light, GLenum pname, GLint *params ) ;
+void xglGetMapdv	( GLenum target, GLenum query, GLdouble *v ) ;
+void xglGetMapfv	( GLenum target, GLenum query, GLfloat *v ) ;
+void xglGetMapiv	( GLenum target, GLenum query, GLint *v ) ;
+void xglGetMaterialfv	( GLenum face, GLenum pname, GLfloat *params ) ;
+void xglGetMaterialiv	( GLenum face, GLenum pname, GLint *params ) ;
+void xglGetPixelMapfv	( GLenum map, GLfloat *values ) ;
+void xglGetPixelMapuiv	( GLenum map, GLuint *values ) ;
+void xglGetPixelMapusv	( GLenum map, GLushort *values ) ;
+void xglGetPointervEXT	( GLenum pname, void **params ) ;
+void xglGetPolygonStipple( GLubyte *mask ) ;
+void xglGetTexEnvfv	( GLenum target, GLenum pname, GLfloat *params ) ;
+void xglGetTexEnviv	( GLenum target, GLenum pname, GLint *params ) ;
+void xglGetTexGendv	( GLenum coord, GLenum pname, GLdouble *params ) ;
+void xglGetTexGenfv	( GLenum coord, GLenum pname, GLfloat *params ) ;
+void xglGetTexGeniv	( GLenum coord, GLenum pname, GLint *params ) ;
+void xglGetTexImage	( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglGetTexLevelParameterfv	( GLenum target, GLint level, GLenum pname, GLfloat *params ) ;
+void xglGetTexLevelParameteriv	( GLenum target, GLint level, GLenum pname, GLint *params ) ;
+void xglGetTexParameterfv	( GLenum target, GLenum pname, GLfloat *params) ;
+void xglGetTexParameteriv	( GLenum target, GLenum pname, GLint *params ) ;
+void xglHint		( GLenum target, GLenum mode ) ;
+void xglIndexMask	( GLuint mask ) ;
+void xglIndexPointerEXT	( GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglIndexd		( GLdouble c ) ;
+void xglIndexdv		( GLdouble *c ) ;
+void xglIndexf		( GLfloat c ) ;
+void xglIndexfv		( GLfloat *c ) ;
+void xglIndexi		( GLint c ) ;
+void xglIndexiv		( GLint *c ) ;
+void xglIndexs		( GLshort c ) ;
+void xglIndexsv		( GLshort *c ) ;
+void xglInitNames	() ;
+void xglLightModelf	( GLenum pname, GLfloat param ) ;
+void xglLightModelfv	( GLenum pname, GLfloat *params ) ;
+void xglLightModeli	( GLenum pname, GLint param ) ;
+void xglLightModeliv	( GLenum pname, GLint *params ) ;
+void xglLightf		( GLenum light, GLenum pname, GLfloat param ) ;
+void xglLightfv		( GLenum light, GLenum pname, GLfloat *params ) ;
+void xglLighti		( GLenum light, GLenum pname, GLint param ) ;
+void xglLightiv		( GLenum light, GLenum pname, GLint *params ) ;
+void xglLineStipple	( GLint factor, GLushort pattern ) ;
+void xglLineWidth	( GLfloat width ) ;
+void xglListBase	( GLuint base ) ;
+void xglLoadIdentity	() ;
+void xglLoadMatrixd	( GLdouble *m ) ;
+void xglLoadMatrixf	( GLfloat *m ) ;
+void xglLoadName	( GLuint name ) ;
+void xglLogicOp		( GLenum opcode ) ;
+void xglMap1d		( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble *points ) ;
+void xglMap1f		( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat *points ) ;
+void xglMap2d		( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble *points ) ;
+void xglMap2f		( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat *points ) ;
+void xglMapGrid1d	( GLint un, GLdouble u1, GLdouble u2 ) ;
+void xglMapGrid1f	( GLint un, GLfloat u1, GLfloat u2 ) ;
+void xglMapGrid2d	( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) ;
+void xglMapGrid2f	( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) ;
+void xglMaterialf	( GLenum face, GLenum pname, GLfloat param ) ;
+void xglMaterialfv	( GLenum face, GLenum pname, GLfloat *params ) ;
+void xglMateriali	( GLenum face, GLenum pname, GLint param ) ;
+void xglMaterialiv	( GLenum face, GLenum pname, GLint *params ) ;
+void xglMatrixMode	( GLenum mode ) ;
+void xglMultMatrixd	( GLdouble *m ) ;
+void xglMultMatrixf	( GLfloat *m ) ;
+void xglNewList		( GLuint list, GLenum mode ) ;
+void xglNormal3b	( GLbyte nx, GLbyte ny, GLbyte nz ) ;
+void xglNormal3bv	( GLbyte *v ) ;
+void xglNormal3d	( GLdouble nx, GLdouble ny, GLdouble nz ) ;
+void xglNormal3dv	( GLdouble *v ) ;
+void xglNormal3f	( GLfloat nx, GLfloat ny, GLfloat nz ) ;
+void xglNormal3fv	( GLfloat *v ) ;
+void xglNormal3i	( GLint nx, GLint ny, GLint nz ) ;
+void xglNormal3iv	( GLint *v ) ;
+void xglNormal3s	( GLshort nx, GLshort ny, GLshort nz ) ;
+void xglNormal3sv	( GLshort *v ) ;
+void xglNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglOrtho		( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) ;
+void xglPassThrough	( GLfloat token ) ;
+void xglPixelMapfv	( GLenum map, GLint mapsize, GLfloat *values ) ;
+void xglPixelMapuiv	( GLenum map, GLint mapsize, GLuint *values ) ;
+void xglPixelMapusv	( GLenum map, GLint mapsize, GLushort *values ) ;
+void xglPixelStoref	( GLenum pname, GLfloat param ) ;
+void xglPixelStorei	( GLenum pname, GLint param ) ;
+void xglPixelTransferf	( GLenum pname, GLfloat param ) ;
+void xglPixelTransferi	( GLenum pname, GLint param ) ;
+void xglPixelZoom	( GLfloat xfactor, GLfloat yfactor ) ;
+void xglPointSize	( GLfloat size ) ;
+void xglPolygonMode	( GLenum face, GLenum mode ) ;
+void xglPolygonOffsetEXT( GLfloat factor, GLfloat bias ) ;
+void xglPolygonOffset   ( GLfloat factor, GLfloat bias ) ;
+void xglPolygonStipple	( GLubyte *mask ) ;
+void xglPopAttrib	() ;
+void xglPopMatrix	() ;
+void xglPopName		() ;
+void xglPushAttrib	( GLbitfield mask ) ;
+void xglPushMatrix	() ;
+void xglPushName	( GLuint name ) ;
+void xglRasterPos2d	( GLdouble x, GLdouble y ) ;
+void xglRasterPos2dv	( GLdouble *v ) ;
+void xglRasterPos2f	( GLfloat x, GLfloat y ) ;
+void xglRasterPos2fv	( GLfloat *v ) ;
+void xglRasterPos2i	( GLint x, GLint y ) ;
+void xglRasterPos2iv	( GLint *v ) ;
+void xglRasterPos2s	( GLshort x, GLshort y ) ;
+void xglRasterPos2sv	( GLshort *v ) ;
+void xglRasterPos3d	( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglRasterPos3dv	( GLdouble *v ) ;
+void xglRasterPos3f	( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglRasterPos3fv	( GLfloat *v ) ;
+void xglRasterPos3i	( GLint x, GLint y, GLint z ) ;
+void xglRasterPos3iv	( GLint *v ) ;
+void xglRasterPos3s	( GLshort x, GLshort y, GLshort z ) ;
+void xglRasterPos3sv	( GLshort *v ) ;
+void xglRasterPos4d	( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) ;
+void xglRasterPos4dv	( GLdouble *v ) ;
+void xglRasterPos4f	( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ;
+void xglRasterPos4fv	( GLfloat *v ) ;
+void xglRasterPos4i	( GLint x, GLint y, GLint z, GLint w ) ;
+void xglRasterPos4iv	( GLint *v ) ;
+void xglRasterPos4s	( GLshort x, GLshort y, GLshort z, GLshort w ) ;
+void xglRasterPos4sv	( GLshort *v ) ;
+void xglReadBuffer	( GLenum mode ) ;
+void xglReadPixels	( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglRectd		( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) ;
+void xglRectdv		( GLdouble *v1, GLdouble *v2 ) ;
+void xglRectf		( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) ;
+void xglRectfv		( GLfloat *v1, GLfloat *v2 ) ;
+void xglRecti		( GLint x1, GLint y1, GLint x2, GLint y2 ) ;
+void xglRectiv		( GLint *v1, GLint *v2 ) ;
+void xglRects		( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) ;
+void xglRectsv		( GLshort *v1, GLshort *v2 ) ;
+void xglRotated		( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) ;
+void xglRotatef		( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) ;
+void xglScaled		( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglScalef		( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglScissor		( GLint x, GLint y, GLsizei width, GLsizei height) ;
+void xglSelectBuffer	( GLsizei size, GLuint *buffer ) ;
+void xglShadeModel	( GLenum mode ) ;
+void xglStencilFunc	( GLenum func, GLint ref, GLuint mask ) ;
+void xglStencilMask	( GLuint mask ) ;
+void xglStencilOp	( GLenum fail, GLenum zfail, GLenum zpass ) ;
+void xglTexCoord1d	( GLdouble s ) ;
+void xglTexCoord1dv	( GLdouble *v ) ;
+void xglTexCoord1f	( GLfloat s ) ;
+void xglTexCoord1fv	( GLfloat *v ) ;
+void xglTexCoord1i	( GLint s ) ;
+void xglTexCoord1iv	( GLint *v ) ;
+void xglTexCoord1s	( GLshort s ) ;
+void xglTexCoord1sv	( GLshort *v ) ;
+void xglTexCoord2d	( GLdouble s, GLdouble t ) ;
+void xglTexCoord2dv	( GLdouble *v ) ;
+void xglTexCoord2f	( GLfloat s, GLfloat t ) ;
+void xglTexCoord2fv	( GLfloat *v ) ;
+void xglTexCoord2i	( GLint s, GLint t ) ;
+void xglTexCoord2iv	( GLint *v ) ;
+void xglTexCoord2s	( GLshort s, GLshort t ) ;
+void xglTexCoord2sv	( GLshort *v ) ;
+void xglTexCoord3d	( GLdouble s, GLdouble t, GLdouble r ) ;
+void xglTexCoord3dv	( GLdouble *v ) ;
+void xglTexCoord3f	( GLfloat s, GLfloat t, GLfloat r ) ;
+void xglTexCoord3fv	( GLfloat *v ) ;
+void xglTexCoord3i	( GLint s, GLint t, GLint r ) ;
+void xglTexCoord3iv	( GLint *v ) ;
+void xglTexCoord3s	( GLshort s, GLshort t, GLshort r ) ;
+void xglTexCoord3sv	( GLshort *v ) ;
+void xglTexCoord4d	( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) ;
+void xglTexCoord4dv	( GLdouble *v ) ;
+void xglTexCoord4f	( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) ;
+void xglTexCoord4fv	( GLfloat *v ) ;
+void xglTexCoord4i	( GLint s, GLint t, GLint r, GLint q ) ;
+void xglTexCoord4iv	( GLint *v ) ;
+void xglTexCoord4s	( GLshort s, GLshort t, GLshort r, GLshort q ) ;
+void xglTexCoord4sv	( GLshort *v ) ;
+void xglTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglTexEnvf		( GLenum target, GLenum pname, GLfloat param ) ;
+void xglTexEnvfv	( GLenum target, GLenum pname, GLfloat *params ) ;
+void xglTexEnvi		( GLenum target, GLenum pname, GLint param ) ;
+void xglTexEnviv	( GLenum target, GLenum pname, GLint *params ) ;
+void xglTexGend		( GLenum coord, GLenum pname, GLdouble param ) ;
+void xglTexGendv	( GLenum coord, GLenum pname, GLdouble *params ) ;
+void xglTexGenf		( GLenum coord, GLenum pname, GLfloat param ) ;
+void xglTexGenfv	( GLenum coord, GLenum pname, GLfloat *params ) ;
+void xglTexGeni		( GLenum coord, GLenum pname, GLint param ) ;
+void xglTexGeniv	( GLenum coord, GLenum pname, GLint *params ) ;
+void xglTexImage1D	( GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglTexImage2D	( GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglTexParameterf	( GLenum target, GLenum pname, GLfloat param ) ;
+void xglTexParameterfv	( GLenum target, GLenum pname, GLfloat *params ) ;
+void xglTexParameteri	( GLenum target, GLenum pname, GLint param ) ;
+void xglTexParameteriv	( GLenum target, GLenum pname, GLint *params ) ;
+void xglTranslated	( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglTranslatef	( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglVertex2d	( GLdouble x, GLdouble y ) ;
+void xglVertex2dv	( GLdouble *v ) ;
+void xglVertex2f	( GLfloat x, GLfloat y ) ;
+void xglVertex2fv	( GLfloat *v ) ;
+void xglVertex2i	( GLint x, GLint y ) ;
+void xglVertex2iv	( GLint *v ) ;
+void xglVertex2s	( GLshort x, GLshort y ) ;
+void xglVertex2sv	( GLshort *v ) ;
+void xglVertex3d	( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglVertex3dv	( GLdouble *v ) ;
+void xglVertex3f	( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglVertex3fv	( GLfloat *v ) ;
+void xglVertex3i	( GLint x, GLint y, GLint z ) ;
+void xglVertex3iv	( GLint *v ) ;
+void xglVertex3s	( GLshort x, GLshort y, GLshort z ) ;
+void xglVertex3sv	( GLshort *v ) ;
+void xglVertex4d	( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) ;
+void xglVertex4dv	( GLdouble *v ) ;
+void xglVertex4f	( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ;
+void xglVertex4fv	( GLfloat *v ) ;
+void xglVertex4i	( GLint x, GLint y, GLint z, GLint w ) ;
+void xglVertex4iv	( GLint *v ) ;
+void xglVertex4s	( GLshort x, GLshort y, GLshort z, GLshort w ) ;
+void xglVertex4sv	( GLshort *v ) ;
+void xglVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglViewport	( GLint x, GLint y, GLsizei width, GLsizei height ) ;
+
+void xglutAddMenuEntry		( char *label, int value ) ;
+void xglutAttachMenu		( int button ) ;
+int  xglutCreateMenu		( void (*)(int) ) ;
+int  xglutCreateWindow		( char *title ) ;
+void xglutDisplayFunc		( void (*)(void) ) ;
+void xglutIdleFunc		( void (*)(void) ) ;
+void xglutInit			( int *argcp, char **argv ) ;
+void xglutInitDisplayMode	( unsigned int mode ) ;
+void xglutInitWindowPosition	( int x, int y ) ;
+void xglutInitWindowSize	( int width, int height ) ;
+void xglutKeyboardFunc		( void (*)(unsigned char key, int x, int y) ) ;
+void xglutMainLoopUpdate	() ;
+void xglutPostRedisplay		() ;
+void xglutPreMainLoop		() ;
+void xglutReshapeFunc		( void (*)(int width, int height) ) ;
+void xglutSwapBuffers		() ;
+
+GLboolean xglAreTexturesResident( GLsizei n, GLuint *textures, GLboolean *residences ) ;
+GLboolean xglIsTexture          ( GLuint texture ) ;
+void xglBindTexture             ( GLenum target, GLuint texture ) ;
+void xglDeleteTextures          ( GLsizei n, GLuint *textures ) ;
+void xglGenTextures             ( GLsizei n, GLuint *textures ) ;
+void xglPrioritizeTextures      ( GLsizei n, GLuint *textures, GLclampf *priorities ) ;
+
+GLboolean xglAreTexturesResidentEXT ( GLsizei n, GLuint *textures, GLboolean *residences ) ;
+GLboolean xglIsTextureEXT           ( GLuint texture ) ;
+void xglBindTextureEXT              ( GLenum target, GLuint texture ) ;
+void xglDeleteTexturesEXT           ( GLsizei n, GLuint *textures ) ;
+void xglGenTexturesEXT              ( GLsizei n, GLuint *textures ) ;
+void xglPrioritizeTexturesEXT       ( GLsizei n, GLuint *textures, GLclampf *priorities ) ;
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _XGL_H */
@@ -0,0 +1,687 @@
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined( __CYGWIN__ ) && !defined( __CYGWIN32__ )
+#  if !defined( HAVE_STL_SGI_PORT ) && !defined( __MWERKS__ )
+//   Avoid malloc with STLport and MSL
+#    include <malloc.h>
+#  endif
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+
+
+#include "xgl.h"
+
+#ifndef TRUE
+#define TRUE  1
+#define FALSE 0
+#endif
+
+int   xglTraceOn = TRUE ;
+
+#ifndef WIN32
+    FILE *xglTraceFd = stdout ;
+#else /* WIN32 */
+    /* Bail for now, we just want it to compile I guess */
+    FILE *xglTraceFd = NULL;
+#endif /* WIN32 */
+
+struct GLenumLookup
+{
+  GLenum val ;
+  char *name ;
+} ;
+
+static struct GLenumLookup glenum_string [] =
+{
+/*
+  Due to ambiguity - these are not in the table...
+
+    GL_NONE = , GL_ZERO = GL_FALSE = GL_POINTS = 0
+    GL_ONE  = , GL_TRUE = GL_LINES = 1
+*/
+  { GL_2D			,"GL_2D" },
+  { GL_2_BYTES			,"GL_2_BYTES" },
+  { GL_3D			,"GL_3D" },
+  { GL_3D_COLOR			,"GL_3D_COLOR" },
+  { GL_3D_COLOR_TEXTURE		,"GL_3D_COLOR_TEXTURE" },
+  { GL_3_BYTES			,"GL_3_BYTES" },
+  { GL_4D_COLOR_TEXTURE		,"GL_4D_COLOR_TEXTURE" },
+  { GL_4_BYTES			,"GL_4_BYTES" },
+  { GL_ACCUM			,"GL_ACCUM" },
+  { GL_ACCUM_ALPHA_BITS		,"GL_ACCUM_ALPHA_BITS" },
+  { GL_ACCUM_BLUE_BITS		,"GL_ACCUM_BLUE_BITS" },
+  { GL_ACCUM_CLEAR_VALUE	,"GL_ACCUM_CLEAR_VALUE" },
+  { GL_ACCUM_GREEN_BITS		,"GL_ACCUM_GREEN_BITS" },
+  { GL_ACCUM_RED_BITS		,"GL_ACCUM_RED_BITS" },
+  { GL_ADD			,"GL_ADD" },
+  { GL_ALPHA			,"GL_ALPHA" },
+  { GL_ALPHA_BIAS		,"GL_ALPHA_BIAS" },
+  { GL_ALPHA_BITS		,"GL_ALPHA_BITS" },
+  { GL_ALPHA_SCALE		,"GL_ALPHA_SCALE" },
+  { GL_ALPHA_TEST		,"GL_ALPHA_TEST" },
+  { GL_ALPHA_TEST_FUNC		,"GL_ALPHA_TEST_FUNC" },
+  { GL_ALPHA_TEST_REF		,"GL_ALPHA_TEST_REF" },
+  { GL_ALWAYS			,"GL_ALWAYS" },
+  { GL_AMBIENT			,"GL_AMBIENT" },
+  { GL_AMBIENT_AND_DIFFUSE	,"GL_AMBIENT_AND_DIFFUSE" },
+  { GL_AND			,"GL_AND" },
+  { GL_AND_INVERTED		,"GL_AND_INVERTED" },
+  { GL_AND_REVERSE		,"GL_AND_REVERSE" },
+  { GL_ATTRIB_STACK_DEPTH	,"GL_ATTRIB_STACK_DEPTH" },
+  { GL_AUTO_NORMAL		,"GL_AUTO_NORMAL" },
+  { GL_AUX0			,"GL_AUX0" },
+  { GL_AUX1			,"GL_AUX1" },
+  { GL_AUX2			,"GL_AUX2" },
+  { GL_AUX3			,"GL_AUX3" },
+  { GL_AUX_BUFFERS		,"GL_AUX_BUFFERS" },
+  { GL_BACK			,"GL_BACK" },
+  { GL_BACK_LEFT		,"GL_BACK_LEFT" },
+  { GL_BACK_RIGHT		,"GL_BACK_RIGHT" },
+  { GL_BITMAP			,"GL_BITMAP" },
+  { GL_BITMAP_TOKEN		,"GL_BITMAP_TOKEN" },
+  { GL_BLEND			,"GL_BLEND" },
+  { GL_BLEND_DST		,"GL_BLEND_DST" },
+#ifdef GL_BLEND_COLOR_EXT
+  { GL_BLEND_COLOR_EXT		,"GL_BLEND_COLOR_EXT" },
+#endif
+#ifdef GL_BLEND_EQUATION_EXT
+  { GL_BLEND_EQUATION_EXT	,"GL_BLEND_EQUATION_EXT" },
+#endif
+  { GL_BLEND_SRC		,"GL_BLEND_SRC" },
+  { GL_BLUE			,"GL_BLUE" },
+  { GL_BLUE_BIAS		,"GL_BLUE_BIAS" },
+  { GL_BLUE_BITS		,"GL_BLUE_BITS" },
+  { GL_BLUE_SCALE		,"GL_BLUE_SCALE" },
+  { GL_BYTE			,"GL_BYTE" },
+  { GL_CCW			,"GL_CCW" },
+  { GL_CLAMP			,"GL_CLAMP" },
+  { GL_CLEAR			,"GL_CLEAR" },
+  { GL_CLIP_PLANE0		,"GL_CLIP_PLANE0" },
+  { GL_CLIP_PLANE1		,"GL_CLIP_PLANE1" },
+  { GL_CLIP_PLANE2		,"GL_CLIP_PLANE2" },
+  { GL_CLIP_PLANE3		,"GL_CLIP_PLANE3" },
+  { GL_CLIP_PLANE4		,"GL_CLIP_PLANE4" },
+  { GL_CLIP_PLANE5		,"GL_CLIP_PLANE5" },
+  { GL_COEFF			,"GL_COEFF" },
+  { GL_COLOR			,"GL_COLOR" },
+#ifdef GL_COLOR_ARRAY_EXT
+  { GL_COLOR_ARRAY_COUNT_EXT	,"GL_COLOR_ARRAY_COUNT_EXT" },
+  { GL_COLOR_ARRAY_EXT		,"GL_COLOR_ARRAY_EXT" },
+  { GL_COLOR_ARRAY_POINTER_EXT	,"GL_COLOR_ARRAY_POINTER_EXT" },
+  { GL_COLOR_ARRAY_SIZE_EXT	,"GL_COLOR_ARRAY_SIZE_EXT" },
+  { GL_COLOR_ARRAY_STRIDE_EXT	,"GL_COLOR_ARRAY_STRIDE_EXT" },
+  { GL_COLOR_ARRAY_TYPE_EXT	,"GL_COLOR_ARRAY_TYPE_EXT" },
+#endif
+  { GL_COLOR_CLEAR_VALUE	,"GL_COLOR_CLEAR_VALUE" },
+  { GL_COLOR_INDEX		,"GL_COLOR_INDEX" },
+  { GL_COLOR_INDEXES		,"GL_COLOR_INDEXES" },
+  { GL_COLOR_MATERIAL		,"GL_COLOR_MATERIAL" },
+  { GL_COLOR_MATERIAL_FACE	,"GL_COLOR_MATERIAL_FACE" },
+  { GL_COLOR_MATERIAL_PARAMETER	,"GL_COLOR_MATERIAL_PARAMETER" },
+  { GL_COLOR_WRITEMASK		,"GL_COLOR_WRITEMASK" },
+  { GL_COMPILE			,"GL_COMPILE" },
+  { GL_COMPILE_AND_EXECUTE	,"GL_COMPILE_AND_EXECUTE" },
+#ifdef GL_CONSTANT_ALPHA_EXT
+  { GL_CONSTANT_ALPHA_EXT	,"GL_CONSTANT_ALPHA_EXT" },
+#endif
+  { GL_CONSTANT_ATTENUATION	,"GL_CONSTANT_ATTENUATION" },
+#ifdef GL_CONSTANT_COLOR_EXT
+  { GL_CONSTANT_COLOR_EXT	,"GL_CONSTANT_COLOR_EXT" },
+#endif
+  { GL_COPY			,"GL_COPY" },
+  { GL_COPY_INVERTED		,"GL_COPY_INVERTED" },
+  { GL_COPY_PIXEL_TOKEN		,"GL_COPY_PIXEL_TOKEN" },
+  { GL_CULL_FACE		,"GL_CULL_FACE" },
+  { GL_CULL_FACE_MODE		,"GL_CULL_FACE_MODE" },
+  { GL_CURRENT_COLOR		,"GL_CURRENT_COLOR" },
+  { GL_CURRENT_INDEX		,"GL_CURRENT_INDEX" },
+  { GL_CURRENT_NORMAL		,"GL_CURRENT_NORMAL" },
+  { GL_CURRENT_RASTER_COLOR	,"GL_CURRENT_RASTER_COLOR" },
+  { GL_CURRENT_RASTER_DISTANCE	,"GL_CURRENT_RASTER_DISTANCE" },
+  { GL_CURRENT_RASTER_INDEX	,"GL_CURRENT_RASTER_INDEX" },
+  { GL_CURRENT_RASTER_POSITION	,"GL_CURRENT_RASTER_POSITION" },
+  { GL_CURRENT_RASTER_POSITION_VALID,"GL_CURRENT_RASTER_POSITION_VALID" },
+  { GL_CURRENT_RASTER_TEXTURE_COORDS,"GL_CURRENT_RASTER_TEXTURE_COORDS" },
+  { GL_CURRENT_TEXTURE_COORDS	,"GL_CURRENT_TEXTURE_COORDS" },
+  { GL_CW			,"GL_CW" },
+  { GL_DECAL			,"GL_DECAL" },
+  { GL_DECR			,"GL_DECR" },
+  { GL_DEPTH			,"GL_DEPTH" },
+  { GL_DEPTH_BIAS		,"GL_DEPTH_BIAS" },
+  { GL_DEPTH_BITS		,"GL_DEPTH_BITS" },
+  { GL_DEPTH_CLEAR_VALUE	,"GL_DEPTH_CLEAR_VALUE" },
+  { GL_DEPTH_COMPONENT		,"GL_DEPTH_COMPONENT" },
+  { GL_DEPTH_FUNC		,"GL_DEPTH_FUNC" },
+  { GL_DEPTH_RANGE		,"GL_DEPTH_RANGE" },
+  { GL_DEPTH_SCALE		,"GL_DEPTH_SCALE" },
+  { GL_DEPTH_TEST		,"GL_DEPTH_TEST" },
+  { GL_DEPTH_WRITEMASK		,"GL_DEPTH_WRITEMASK" },
+  { GL_DIFFUSE			,"GL_DIFFUSE" },
+  { GL_DITHER			,"GL_DITHER" },
+  { GL_DOMAIN			,"GL_DOMAIN" },
+  { GL_DONT_CARE		,"GL_DONT_CARE" },
+  { GL_DOUBLEBUFFER		,"GL_DOUBLEBUFFER" },
+#ifdef GL_DOUBLE_EXT
+  { GL_DOUBLE_EXT		,"GL_DOUBLE_EXT" },
+#endif
+  { GL_DRAW_BUFFER		,"GL_DRAW_BUFFER" },
+  { GL_DRAW_PIXEL_TOKEN		,"GL_DRAW_PIXEL_TOKEN" },
+  { GL_DST_ALPHA		,"GL_DST_ALPHA" },
+  { GL_DST_COLOR		,"GL_DST_COLOR" },
+  { GL_EDGE_FLAG		,"GL_EDGE_FLAG" },
+#ifdef GL_EDGE_FLAG_ARRAY_EXT
+  { GL_EDGE_FLAG_ARRAY_COUNT_EXT,"GL_EDGE_FLAG_ARRAY_COUNT_EXT" },
+  { GL_EDGE_FLAG_ARRAY_EXT	,"GL_EDGE_FLAG_ARRAY_EXT" },
+  { GL_EDGE_FLAG_ARRAY_POINTER_EXT,"GL_EDGE_FLAG_ARRAY_POINTER_EXT" },
+  { GL_EDGE_FLAG_ARRAY_STRIDE_EXT,"GL_EDGE_FLAG_ARRAY_STRIDE_EXT" },
+#endif
+  { GL_EMISSION			,"GL_EMISSION" },
+  { GL_EQUAL			,"GL_EQUAL" },
+  { GL_EQUIV			,"GL_EQUIV" },
+  { GL_EXP			,"GL_EXP" },
+  { GL_EXP2			,"GL_EXP2" },
+  { GL_EXTENSIONS		,"GL_EXTENSIONS" },
+  { GL_EYE_LINEAR		,"GL_EYE_LINEAR" },
+  { GL_EYE_PLANE		,"GL_EYE_PLANE" },
+  { GL_FASTEST			,"GL_FASTEST" },
+  { GL_FEEDBACK			,"GL_FEEDBACK" },
+  { GL_FILL			,"GL_FILL" },
+  { GL_FLAT			,"GL_FLAT" },
+  { GL_FLOAT			,"GL_FLOAT" },
+  { GL_FOG			,"GL_FOG" },
+  { GL_FOG_COLOR		,"GL_FOG_COLOR" },
+  { GL_FOG_DENSITY		,"GL_FOG_DENSITY" },
+  { GL_FOG_END			,"GL_FOG_END" },
+  { GL_FOG_HINT			,"GL_FOG_HINT" },
+  { GL_FOG_INDEX		,"GL_FOG_INDEX" },
+  { GL_FOG_MODE			,"GL_FOG_MODE" },
+  { GL_FOG_START		,"GL_FOG_START" },
+  { GL_FRONT			,"GL_FRONT" },
+  { GL_FRONT_AND_BACK		,"GL_FRONT_AND_BACK" },
+  { GL_FRONT_FACE		,"GL_FRONT_FACE" },
+  { GL_FRONT_LEFT		,"GL_FRONT_LEFT" },
+  { GL_FRONT_RIGHT		,"GL_FRONT_RIGHT" },
+#ifdef GL_FUNC_ADD_EXT
+  { GL_FUNC_ADD_EXT		,"GL_FUNC_ADD_EXT" },
+  { GL_FUNC_REVERSE_SUBTRACT_EXT,"GL_FUNC_REVERSE_SUBTRACT_EXT" },
+  { GL_FUNC_SUBTRACT_EXT	,"GL_FUNC_SUBTRACT_EXT" },
+#endif
+  { GL_GEQUAL			,"GL_GEQUAL" },
+  { GL_GREATER			,"GL_GREATER" },
+  { GL_GREEN			,"GL_GREEN" },
+  { GL_GREEN_BIAS		,"GL_GREEN_BIAS" },
+  { GL_GREEN_BITS		,"GL_GREEN_BITS" },
+  { GL_GREEN_SCALE		,"GL_GREEN_SCALE" },
+  { GL_INCR			,"GL_INCR" },
+#ifdef GL_INDEX_ARRAY_EXT
+  { GL_INDEX_ARRAY_COUNT_EXT	,"GL_INDEX_ARRAY_COUNT_EXT" },
+  { GL_INDEX_ARRAY_EXT		,"GL_INDEX_ARRAY_EXT" },
+  { GL_INDEX_ARRAY_POINTER_EXT	,"GL_INDEX_ARRAY_POINTER_EXT" },
+  { GL_INDEX_ARRAY_STRIDE_EXT	,"GL_INDEX_ARRAY_STRIDE_EXT" },
+  { GL_INDEX_ARRAY_TYPE_EXT	,"GL_INDEX_ARRAY_TYPE_EXT" },
+#endif
+  { GL_INDEX_BITS		,"GL_INDEX_BITS" },
+  { GL_INDEX_CLEAR_VALUE	,"GL_INDEX_CLEAR_VALUE" },
+  { GL_INDEX_MODE		,"GL_INDEX_MODE" },
+  { GL_INDEX_OFFSET		,"GL_INDEX_OFFSET" },
+  { GL_INDEX_SHIFT		,"GL_INDEX_SHIFT" },
+  { GL_INDEX_WRITEMASK		,"GL_INDEX_WRITEMASK" },
+  { GL_INT			,"GL_INT" },
+  { GL_INVALID_ENUM		,"GL_INVALID_ENUM" },
+  { GL_INVALID_OPERATION	,"GL_INVALID_OPERATION" },
+  { GL_INVALID_VALUE		,"GL_INVALID_VALUE" },
+  { GL_INVERT			,"GL_INVERT" },
+  { GL_KEEP			,"GL_KEEP" },
+  { GL_LEFT			,"GL_LEFT" },
+  { GL_LEQUAL			,"GL_LEQUAL" },
+  { GL_LESS			,"GL_LESS" },
+  { GL_LIGHT0			,"GL_LIGHT0" },
+  { GL_LIGHT1			,"GL_LIGHT1" },
+  { GL_LIGHT2			,"GL_LIGHT2" },
+  { GL_LIGHT3			,"GL_LIGHT3" },
+  { GL_LIGHT4			,"GL_LIGHT4" },
+  { GL_LIGHT5			,"GL_LIGHT5" },
+  { GL_LIGHT6			,"GL_LIGHT6" },
+  { GL_LIGHT7			,"GL_LIGHT7" },
+  { GL_LIGHTING			,"GL_LIGHTING" },
+  { GL_LIGHT_MODEL_AMBIENT	,"GL_LIGHT_MODEL_AMBIENT" },
+  { GL_LIGHT_MODEL_LOCAL_VIEWER	,"GL_LIGHT_MODEL_LOCAL_VIEWER" },
+  { GL_LIGHT_MODEL_TWO_SIDE	,"GL_LIGHT_MODEL_TWO_SIDE" },
+  { GL_LINE			,"GL_LINE" },
+  { GL_LINEAR			,"GL_LINEAR" },
+  { GL_LINEAR_ATTENUATION	,"GL_LINEAR_ATTENUATION" },
+  { GL_LINEAR_MIPMAP_LINEAR	,"GL_LINEAR_MIPMAP_LINEAR" },
+  { GL_LINEAR_MIPMAP_NEAREST	,"GL_LINEAR_MIPMAP_NEAREST" },
+  { GL_LINE_LOOP		,"GL_LINE_LOOP" },
+  { GL_LINE_RESET_TOKEN		,"GL_LINE_RESET_TOKEN" },
+  { GL_LINE_SMOOTH		,"GL_LINE_SMOOTH" },
+  { GL_LINE_SMOOTH_HINT		,"GL_LINE_SMOOTH_HINT" },
+  { GL_LINE_STIPPLE		,"GL_LINE_STIPPLE" },
+  { GL_LINE_STIPPLE_PATTERN	,"GL_LINE_STIPPLE_PATTERN" },
+  { GL_LINE_STIPPLE_REPEAT	,"GL_LINE_STIPPLE_REPEAT" },
+  { GL_LINE_STRIP		,"GL_LINE_STRIP" },
+  { GL_LINE_TOKEN		,"GL_LINE_TOKEN" },
+  { GL_LINE_WIDTH		,"GL_LINE_WIDTH" },
+  { GL_LINE_WIDTH_GRANULARITY	,"GL_LINE_WIDTH_GRANULARITY" },
+  { GL_LINE_WIDTH_RANGE		,"GL_LINE_WIDTH_RANGE" },
+  { GL_LIST_BASE		,"GL_LIST_BASE" },
+  { GL_LIST_INDEX		,"GL_LIST_INDEX" },
+  { GL_LIST_MODE		,"GL_LIST_MODE" },
+  { GL_LOAD			,"GL_LOAD" },
+  { GL_LOGIC_OP			,"GL_LOGIC_OP" },
+  { GL_LOGIC_OP_MODE		,"GL_LOGIC_OP_MODE" },
+  { GL_LUMINANCE		,"GL_LUMINANCE" },
+  { GL_LUMINANCE_ALPHA		,"GL_LUMINANCE_ALPHA" },
+  { GL_MAP1_COLOR_4		,"GL_MAP1_COLOR_4" },
+  { GL_MAP1_GRID_DOMAIN		,"GL_MAP1_GRID_DOMAIN" },
+  { GL_MAP1_GRID_SEGMENTS	,"GL_MAP1_GRID_SEGMENTS" },
+  { GL_MAP1_INDEX		,"GL_MAP1_INDEX" },
+  { GL_MAP1_NORMAL		,"GL_MAP1_NORMAL" },
+  { GL_MAP1_TEXTURE_COORD_1	,"GL_MAP1_TEXTURE_COORD_1" },
+  { GL_MAP1_TEXTURE_COORD_2	,"GL_MAP1_TEXTURE_COORD_2" },
+  { GL_MAP1_TEXTURE_COORD_3	,"GL_MAP1_TEXTURE_COORD_3" },
+  { GL_MAP1_TEXTURE_COORD_4	,"GL_MAP1_TEXTURE_COORD_4" },
+  { GL_MAP1_VERTEX_3		,"GL_MAP1_VERTEX_3" },
+  { GL_MAP1_VERTEX_4		,"GL_MAP1_VERTEX_4" },
+  { GL_MAP2_COLOR_4		,"GL_MAP2_COLOR_4" },
+  { GL_MAP2_GRID_DOMAIN		,"GL_MAP2_GRID_DOMAIN" },
+  { GL_MAP2_GRID_SEGMENTS	,"GL_MAP2_GRID_SEGMENTS" },
+  { GL_MAP2_INDEX		,"GL_MAP2_INDEX" },
+  { GL_MAP2_NORMAL		,"GL_MAP2_NORMAL" },
+  { GL_MAP2_TEXTURE_COORD_1	,"GL_MAP2_TEXTURE_COORD_1" },
+  { GL_MAP2_TEXTURE_COORD_2	,"GL_MAP2_TEXTURE_COORD_2" },
+  { GL_MAP2_TEXTURE_COORD_3	,"GL_MAP2_TEXTURE_COORD_3" },
+  { GL_MAP2_TEXTURE_COORD_4	,"GL_MAP2_TEXTURE_COORD_4" },
+  { GL_MAP2_VERTEX_3		,"GL_MAP2_VERTEX_3" },
+  { GL_MAP2_VERTEX_4		,"GL_MAP2_VERTEX_4" },
+  { GL_MAP_COLOR		,"GL_MAP_COLOR" },
+  { GL_MAP_STENCIL		,"GL_MAP_STENCIL" },
+  { GL_MATRIX_MODE		,"GL_MATRIX_MODE" },
+  { GL_MAX_ATTRIB_STACK_DEPTH	,"GL_MAX_ATTRIB_STACK_DEPTH" },
+  { GL_MAX_CLIP_PLANES		,"GL_MAX_CLIP_PLANES" },
+  { GL_MAX_EVAL_ORDER		,"GL_MAX_EVAL_ORDER" },
+#ifdef GL_MAX_EXT
+  { GL_MAX_EXT			,"GL_MAX_EXT" },
+#endif
+  { GL_MAX_LIGHTS		,"GL_MAX_LIGHTS" },
+  { GL_MAX_LIST_NESTING		,"GL_MAX_LIST_NESTING" },
+  { GL_MAX_MODELVIEW_STACK_DEPTH,"GL_MAX_MODELVIEW_STACK_DEPTH" },
+  { GL_MAX_NAME_STACK_DEPTH	,"GL_MAX_NAME_STACK_DEPTH" },
+  { GL_MAX_PIXEL_MAP_TABLE	,"GL_MAX_PIXEL_MAP_TABLE" },
+  { GL_MAX_PROJECTION_STACK_DEPTH,"GL_MAX_PROJECTION_STACK_DEPTH" },
+  { GL_MAX_TEXTURE_SIZE		,"GL_MAX_TEXTURE_SIZE" },
+  { GL_MAX_TEXTURE_STACK_DEPTH	,"GL_MAX_TEXTURE_STACK_DEPTH" },
+  { GL_MAX_VIEWPORT_DIMS	,"GL_MAX_VIEWPORT_DIMS" },
+#ifdef GL_MIN_EXT
+  { GL_MIN_EXT			,"GL_MIN_EXT" },
+#endif
+  { GL_MODELVIEW		,"GL_MODELVIEW" },
+  { GL_MODELVIEW_MATRIX		,"GL_MODELVIEW_MATRIX" },
+  { GL_MODELVIEW_STACK_DEPTH	,"GL_MODELVIEW_STACK_DEPTH" },
+  { GL_MODULATE			,"GL_MODULATE" },
+  { GL_MULT			,"GL_MULT" },
+  { GL_NAME_STACK_DEPTH		,"GL_NAME_STACK_DEPTH" },
+  { GL_NAND			,"GL_NAND" },
+  { GL_NEAREST			,"GL_NEAREST" },
+  { GL_NEAREST_MIPMAP_LINEAR	,"GL_NEAREST_MIPMAP_LINEAR" },
+  { GL_NEAREST_MIPMAP_NEAREST	,"GL_NEAREST_MIPMAP_NEAREST" },
+  { GL_NEVER			,"GL_NEVER" },
+  { GL_NICEST			,"GL_NICEST" },
+  { GL_NOOP			,"GL_NOOP" },
+  { GL_NOR			,"GL_NOR" },
+  { GL_NORMALIZE		,"GL_NORMALIZE" },
+#ifdef GL_NORMAL_ARRAY_EXT
+  { GL_NORMAL_ARRAY_COUNT_EXT	,"GL_NORMAL_ARRAY_COUNT_EXT" },
+  { GL_NORMAL_ARRAY_EXT		,"GL_NORMAL_ARRAY_EXT" },
+  { GL_NORMAL_ARRAY_POINTER_EXT	,"GL_NORMAL_ARRAY_POINTER_EXT" },
+  { GL_NORMAL_ARRAY_STRIDE_EXT	,"GL_NORMAL_ARRAY_STRIDE_EXT" },
+  { GL_NORMAL_ARRAY_TYPE_EXT	,"GL_NORMAL_ARRAY_TYPE_EXT" },
+#endif
+  { GL_NOTEQUAL			,"GL_NOTEQUAL" },
+  { GL_OBJECT_LINEAR		,"GL_OBJECT_LINEAR" },
+  { GL_OBJECT_PLANE		,"GL_OBJECT_PLANE" },
+#ifdef GL_ONE_MINUS_CONSTANT_ALPHA_EXT
+  { GL_ONE_MINUS_CONSTANT_ALPHA_EXT,"GL_ONE_MINUS_CONSTANT_ALPHA_EXT" },
+  { GL_ONE_MINUS_CONSTANT_COLOR_EXT,"GL_ONE_MINUS_CONSTANT_COLOR_EXT" },
+#endif
+  { GL_ONE_MINUS_DST_ALPHA	,"GL_ONE_MINUS_DST_ALPHA" },
+  { GL_ONE_MINUS_DST_COLOR	,"GL_ONE_MINUS_DST_COLOR" },
+  { GL_ONE_MINUS_SRC_ALPHA	,"GL_ONE_MINUS_SRC_ALPHA" },
+  { GL_ONE_MINUS_SRC_COLOR	,"GL_ONE_MINUS_SRC_COLOR" },
+  { GL_OR			,"GL_OR" },
+  { GL_ORDER			,"GL_ORDER" },
+  { GL_OR_INVERTED		,"GL_OR_INVERTED" },
+  { GL_OR_REVERSE		,"GL_OR_REVERSE" },
+  { GL_OUT_OF_MEMORY		,"GL_OUT_OF_MEMORY" },
+  { GL_PACK_ALIGNMENT		,"GL_PACK_ALIGNMENT" },
+  { GL_PACK_LSB_FIRST		,"GL_PACK_LSB_FIRST" },
+  { GL_PACK_ROW_LENGTH		,"GL_PACK_ROW_LENGTH" },
+  { GL_PACK_SKIP_PIXELS		,"GL_PACK_SKIP_PIXELS" },
+  { GL_PACK_SKIP_ROWS		,"GL_PACK_SKIP_ROWS" },
+  { GL_PACK_SWAP_BYTES		,"GL_PACK_SWAP_BYTES" },
+  { GL_PASS_THROUGH_TOKEN	,"GL_PASS_THROUGH_TOKEN" },
+  { GL_PERSPECTIVE_CORRECTION_HINT,"GL_PERSPECTIVE_CORRECTION_HINT" },
+  { GL_PIXEL_MAP_A_TO_A		,"GL_PIXEL_MAP_A_TO_A" },
+  { GL_PIXEL_MAP_A_TO_A_SIZE	,"GL_PIXEL_MAP_A_TO_A_SIZE" },
+  { GL_PIXEL_MAP_B_TO_B		,"GL_PIXEL_MAP_B_TO_B" },
+  { GL_PIXEL_MAP_B_TO_B_SIZE	,"GL_PIXEL_MAP_B_TO_B_SIZE" },
+  { GL_PIXEL_MAP_G_TO_G		,"GL_PIXEL_MAP_G_TO_G" },
+  { GL_PIXEL_MAP_G_TO_G_SIZE	,"GL_PIXEL_MAP_G_TO_G_SIZE" },
+  { GL_PIXEL_MAP_I_TO_A		,"GL_PIXEL_MAP_I_TO_A" },
+  { GL_PIXEL_MAP_I_TO_A_SIZE	,"GL_PIXEL_MAP_I_TO_A_SIZE" },
+  { GL_PIXEL_MAP_I_TO_B		,"GL_PIXEL_MAP_I_TO_B" },
+  { GL_PIXEL_MAP_I_TO_B_SIZE	,"GL_PIXEL_MAP_I_TO_B_SIZE" },
+  { GL_PIXEL_MAP_I_TO_G		,"GL_PIXEL_MAP_I_TO_G" },
+  { GL_PIXEL_MAP_I_TO_G_SIZE	,"GL_PIXEL_MAP_I_TO_G_SIZE" },
+  { GL_PIXEL_MAP_I_TO_I		,"GL_PIXEL_MAP_I_TO_I" },
+  { GL_PIXEL_MAP_I_TO_I_SIZE	,"GL_PIXEL_MAP_I_TO_I_SIZE" },
+  { GL_PIXEL_MAP_I_TO_R		,"GL_PIXEL_MAP_I_TO_R" },
+  { GL_PIXEL_MAP_I_TO_R_SIZE	,"GL_PIXEL_MAP_I_TO_R_SIZE" },
+  { GL_PIXEL_MAP_R_TO_R		,"GL_PIXEL_MAP_R_TO_R" },
+  { GL_PIXEL_MAP_R_TO_R_SIZE	,"GL_PIXEL_MAP_R_TO_R_SIZE" },
+  { GL_PIXEL_MAP_S_TO_S		,"GL_PIXEL_MAP_S_TO_S" },
+  { GL_PIXEL_MAP_S_TO_S_SIZE	,"GL_PIXEL_MAP_S_TO_S_SIZE" },
+  { GL_POINT			,"GL_POINT" },
+  { GL_POINT_SIZE		,"GL_POINT_SIZE" },
+  { GL_POINT_SIZE_GRANULARITY 	,"GL_POINT_SIZE_GRANULARITY" },
+  { GL_POINT_SIZE_RANGE		,"GL_POINT_SIZE_RANGE" },
+  { GL_POINT_SMOOTH		,"GL_POINT_SMOOTH" },
+  { GL_POINT_SMOOTH_HINT	,"GL_POINT_SMOOTH_HINT" },
+  { GL_POINT_TOKEN		,"GL_POINT_TOKEN" },
+  { GL_POLYGON			,"GL_POLYGON" },
+  { GL_POLYGON_MODE		,"GL_POLYGON_MODE" },
+  { GL_POLYGON_SMOOTH		,"GL_POLYGON_SMOOTH" },
+  { GL_POLYGON_SMOOTH_HINT	,"GL_POLYGON_SMOOTH_HINT" },
+  { GL_POLYGON_STIPPLE		,"GL_POLYGON_STIPPLE" },
+#ifdef GL_POLYGON_OFFSET_EXT
+  { GL_POLYGON_OFFSET_BIAS_EXT  ,"GL_POLYGON_OFFSET_BIAS_EXT" },
+  { GL_POLYGON_OFFSET_EXT       ,"GL_POLYGON_OFFSET_EXT" },
+  { GL_POLYGON_OFFSET_FACTOR_EXT,"GL_POLYGON_OFFSET_FACTOR_EXT" },
+#endif
+  { GL_POLYGON_TOKEN		,"GL_POLYGON_TOKEN" },
+  { GL_POSITION			,"GL_POSITION" },
+  { GL_PROJECTION		,"GL_PROJECTION" },
+  { GL_PROJECTION_MATRIX	,"GL_PROJECTION_MATRIX" },
+  { GL_PROJECTION_STACK_DEPTH	,"GL_PROJECTION_STACK_DEPTH" },
+  { GL_Q			,"GL_Q" },
+  { GL_QUADRATIC_ATTENUATION	,"GL_QUADRATIC_ATTENUATION" },
+  { GL_QUADS			,"GL_QUADS" },
+  { GL_QUAD_STRIP		,"GL_QUAD_STRIP" },
+  { GL_R			,"GL_R" },
+  { GL_READ_BUFFER		,"GL_READ_BUFFER" },
+  { GL_RED			,"GL_RED" },
+  { GL_RED_BIAS			,"GL_RED_BIAS" },
+  { GL_RED_BITS			,"GL_RED_BITS" },
+  { GL_RED_SCALE		,"GL_RED_SCALE" },
+  { GL_RENDER			,"GL_RENDER" },
+  { GL_RENDERER			,"GL_RENDERER" },
+  { GL_RENDER_MODE		,"GL_RENDER_MODE" },
+  { GL_REPEAT			,"GL_REPEAT" },
+  { GL_REPLACE			,"GL_REPLACE" },
+#ifdef GL_REPLACE_EXT
+  { GL_REPLACE_EXT		,"GL_REPLACE_EXT" },
+#endif
+  { GL_RETURN			,"GL_RETURN" },
+  { GL_RGB			,"GL_RGB" },
+  { GL_RGBA			,"GL_RGBA" },
+  { GL_RGBA_MODE		,"GL_RGBA_MODE" },
+  { GL_RIGHT			,"GL_RIGHT" },
+  { GL_S			,"GL_S" },
+  { GL_SCISSOR_BOX		,"GL_SCISSOR_BOX" },
+  { GL_SCISSOR_TEST		,"GL_SCISSOR_TEST" },
+  { GL_SELECT			,"GL_SELECT" },
+  { GL_SET			,"GL_SET" },
+  { GL_SHADE_MODEL		,"GL_SHADE_MODEL" },
+  { GL_SHININESS		,"GL_SHININESS" },
+  { GL_SHORT			,"GL_SHORT" },
+  { GL_SMOOTH			,"GL_SMOOTH" },
+  { GL_SPECULAR			,"GL_SPECULAR" },
+  { GL_SPHERE_MAP		,"GL_SPHERE_MAP" },
+  { GL_SPOT_CUTOFF		,"GL_SPOT_CUTOFF" },
+  { GL_SPOT_DIRECTION		,"GL_SPOT_DIRECTION" },
+  { GL_SPOT_EXPONENT		,"GL_SPOT_EXPONENT" },
+  { GL_SRC_ALPHA		,"GL_SRC_ALPHA" },
+  { GL_SRC_ALPHA_SATURATE	,"GL_SRC_ALPHA_SATURATE" },
+  { GL_SRC_COLOR		,"GL_SRC_COLOR" },
+  { GL_STACK_OVERFLOW		,"GL_STACK_OVERFLOW" },
+  { GL_STACK_UNDERFLOW		,"GL_STACK_UNDERFLOW" },
+  { GL_STENCIL			,"GL_STENCIL" },
+  { GL_STENCIL_BITS		,"GL_STENCIL_BITS" },
+  { GL_STENCIL_CLEAR_VALUE	,"GL_STENCIL_CLEAR_VALUE" },
+  { GL_STENCIL_FAIL		,"GL_STENCIL_FAIL" },
+  { GL_STENCIL_FUNC		,"GL_STENCIL_FUNC" },
+  { GL_STENCIL_INDEX		,"GL_STENCIL_INDEX" },
+  { GL_STENCIL_PASS_DEPTH_FAIL	,"GL_STENCIL_PASS_DEPTH_FAIL" },
+  { GL_STENCIL_PASS_DEPTH_PASS	,"GL_STENCIL_PASS_DEPTH_PASS" },
+  { GL_STENCIL_REF		,"GL_STENCIL_REF" },
+  { GL_STENCIL_TEST		,"GL_STENCIL_TEST" },
+  { GL_STENCIL_VALUE_MASK	,"GL_STENCIL_VALUE_MASK" },
+  { GL_STENCIL_WRITEMASK	,"GL_STENCIL_WRITEMASK" },
+  { GL_STEREO			,"GL_STEREO" },
+  { GL_SUBPIXEL_BITS		,"GL_SUBPIXEL_BITS" },
+  { GL_T			,"GL_T" },
+  { GL_TEXTURE			,"GL_TEXTURE" },
+  { GL_TEXTURE_1D		,"GL_TEXTURE_1D" },
+  { GL_TEXTURE_2D		,"GL_TEXTURE_2D" },
+  { GL_TEXTURE_BORDER		,"GL_TEXTURE_BORDER" },
+  { GL_TEXTURE_BORDER_COLOR	,"GL_TEXTURE_BORDER_COLOR" },
+  { GL_TEXTURE_COMPONENTS	,"GL_TEXTURE_COMPONENTS" },
+#ifdef GL_TEXTURE_COORD_ARRAY_EXT
+  { GL_TEXTURE_COORD_ARRAY_COUNT_EXT,"GL_TEXTURE_COORD_ARRAY_COUNT_EXT" },
+  { GL_TEXTURE_COORD_ARRAY_EXT	,"GL_TEXTURE_COORD_ARRAY_EXT" },
+  { GL_TEXTURE_COORD_ARRAY_POINTER_EXT,"GL_TEXTURE_COORD_ARRAY_POINTER_EXT" },
+  { GL_TEXTURE_COORD_ARRAY_SIZE_EXT,"GL_TEXTURE_COORD_ARRAY_SIZE_EXT" },
+  { GL_TEXTURE_COORD_ARRAY_STRIDE_EXT,"GL_TEXTURE_COORD_ARRAY_STRIDE_EXT" },
+  { GL_TEXTURE_COORD_ARRAY_TYPE_EXT,"GL_TEXTURE_COORD_ARRAY_TYPE_EXT" },
+#endif
+  { GL_TEXTURE_ENV		,"GL_TEXTURE_ENV" },
+  { GL_TEXTURE_ENV_COLOR	,"GL_TEXTURE_ENV_COLOR" },
+  { GL_TEXTURE_ENV_MODE		,"GL_TEXTURE_ENV_MODE" },
+  { GL_TEXTURE_GEN_MODE		,"GL_TEXTURE_GEN_MODE" },
+  { GL_TEXTURE_GEN_Q		,"GL_TEXTURE_GEN_Q" },
+  { GL_TEXTURE_GEN_R		,"GL_TEXTURE_GEN_R" },
+  { GL_TEXTURE_GEN_S		,"GL_TEXTURE_GEN_S" },
+  { GL_TEXTURE_GEN_T		,"GL_TEXTURE_GEN_T" },
+  { GL_TEXTURE_HEIGHT		,"GL_TEXTURE_HEIGHT" },
+  { GL_TEXTURE_MAG_FILTER	,"GL_TEXTURE_MAG_FILTER" },
+  { GL_TEXTURE_MATRIX		,"GL_TEXTURE_MATRIX" },
+  { GL_TEXTURE_MIN_FILTER	,"GL_TEXTURE_MIN_FILTER" },
+  { GL_TEXTURE_STACK_DEPTH	,"GL_TEXTURE_STACK_DEPTH" },
+  { GL_TEXTURE_WIDTH		,"GL_TEXTURE_WIDTH" },
+  { GL_TEXTURE_WRAP_S		,"GL_TEXTURE_WRAP_S" },
+  { GL_TEXTURE_WRAP_T		,"GL_TEXTURE_WRAP_T" },
+  { GL_TRIANGLES		,"GL_TRIANGLES" },
+  { GL_TRIANGLE_FAN		,"GL_TRIANGLE_FAN" },
+  { GL_TRIANGLE_STRIP		,"GL_TRIANGLE_STRIP" },
+  { GL_UNPACK_ALIGNMENT		,"GL_UNPACK_ALIGNMENT" },
+  { GL_UNPACK_LSB_FIRST		,"GL_UNPACK_LSB_FIRST" },
+  { GL_UNPACK_ROW_LENGTH	,"GL_UNPACK_ROW_LENGTH" },
+  { GL_UNPACK_SKIP_PIXELS	,"GL_UNPACK_SKIP_PIXELS" },
+  { GL_UNPACK_SKIP_ROWS		,"GL_UNPACK_SKIP_ROWS" },
+  { GL_UNPACK_SWAP_BYTES	,"GL_UNPACK_SWAP_BYTES" },
+  { GL_UNSIGNED_BYTE		,"GL_UNSIGNED_BYTE" },
+  { GL_UNSIGNED_INT		,"GL_UNSIGNED_INT" },
+  { GL_UNSIGNED_SHORT		,"GL_UNSIGNED_SHORT" },
+  { GL_VENDOR			,"GL_VENDOR" },
+  { GL_VERSION			,"GL_VERSION" },
+#ifdef GL_VERTEX_ARRAY_EXT
+  { GL_VERTEX_ARRAY_COUNT_EXT	,"GL_VERTEX_ARRAY_COUNT_EXT" },
+  { GL_VERTEX_ARRAY_EXT		,"GL_VERTEX_ARRAY_EXT" },
+  { GL_VERTEX_ARRAY_POINTER_EXT	,"GL_VERTEX_ARRAY_POINTER_EXT" },
+  { GL_VERTEX_ARRAY_SIZE_EXT	,"GL_VERTEX_ARRAY_SIZE_EXT" },
+  { GL_VERTEX_ARRAY_STRIDE_EXT	,"GL_VERTEX_ARRAY_STRIDE_EXT" },
+  { GL_VERTEX_ARRAY_TYPE_EXT	,"GL_VERTEX_ARRAY_TYPE_EXT" },
+#endif
+  { GL_VIEWPORT			,"GL_VIEWPORT" },
+  { GL_XOR			,"GL_XOR" },
+  { GL_ZOOM_X			,"GL_ZOOM_X" },
+  { GL_ZOOM_Y			,"GL_ZOOM_Y" },
+
+  /* Magic end-marker - do not remove! */
+  { GL_ZERO, NULL }
+} ;
+
+
+int xglTraceIsEnabled ( char *gl_function_name )
+{
+  static int frameno   = 0 ;
+  static int countdown = 0 ;
+
+  if ( strcmp ( gl_function_name, "glutSwapBuffers" ) == 0 )
+  {
+    if ( countdown == 0 )
+    {
+      char s [ 100 ] ;
+
+      fprintf ( stderr, "\nContinue Tracing after frame %d [Yes,No,Countdown,eXit] ?", ++frameno ) ;
+      gets ( s ) ;
+
+      if ( s[0] == 'x' )
+        exit ( 1 ) ;
+
+      xglTraceOn = ( s[0] != 'n' && s[0] != 'c' ) ;
+
+      if ( s[0] == 'c' )
+      {
+	fprintf ( stderr, "\nHow many frames should I wait until I ask again?" ) ;
+	gets ( s ) ;
+	countdown = atoi(s) ;
+      }
+
+      fprintf ( xglTraceFd, "/* Frame %d - tracing %s */\n", frameno, xglTraceOn ? "ON" : "OFF" ) ;
+    }
+    else
+      countdown-- ;
+  }
+
+  return xglTraceOn ;
+}
+
+
+int xglExecuteIsEnabled ( char *gl_function_name )
+{
+  return TRUE ;
+}
+
+char *xglExpandGLenum ( GLenum x )
+{
+  static GLenum last_val = GL_NONE ;
+  static char  *last_str = NULL ;
+  char *error_message;
+  int i;
+
+  /* Due to ambiguity - these are output as numbers...
+
+      GL_NONE = , GL_ZERO = GL_FALSE = GL_POINTS = 0
+      GL_ONE  = , GL_TRUE = GL_LINES = 1
+  */
+
+  if ( (int) x == 0 ) return "(GLenum) 0" ;
+  if ( (int) x == 1 ) return "(GLenum) 1" ;
+
+  if ( last_val == x ) return last_str ;
+
+  for ( i = 0 ; glenum_string [i].name != NULL ; i++ )
+    if ( glenum_string [i].val == x )
+      return  glenum_string [i].name ;
+
+  /*
+    WARNING - this will leak memory - but it is an error condition,
+              so I suppose it's acceptable.
+              You can't declare the 'error_message' string as a
+              static - or else double errors will go mis-reported.
+  */
+
+  error_message = (char *)malloc( 100 * sizeof(char) ) ;
+
+  sprintf ( error_message, "(GLenum) 0x%04x /* Illegal? */", (int) x ) ;
+
+  return error_message ;
+}
+
+static GLbyte    b1 [ 1 ],  b2 [ 2 ],  b3 [ 3 ],  b4 [ 4 ] ;
+static GLdouble  d1 [ 1 ],  d2 [ 2 ],  d3 [ 3 ],  d4 [ 4 ] ;
+static GLfloat   f1 [ 1 ],  f2 [ 2 ],  f3 [ 3 ],  f4 [ 4 ] ;
+static GLint     i1 [ 1 ],  i2 [ 2 ],  i3 [ 3 ],  i4 [ 4 ] ;
+static GLshort   s1 [ 1 ],  s2 [ 2 ],  s3 [ 3 ],  s4 [ 4 ] ;
+static GLubyte  ub1 [ 1 ], ub2 [ 2 ], ub3 [ 3 ], ub4 [ 4 ] ;
+static GLuint   ui1 [ 1 ], ui2 [ 2 ], ui3 [ 3 ], ui4 [ 4 ] ;
+static GLushort us1 [ 1 ], us2 [ 2 ], us3 [ 3 ], us4 [ 4 ] ;
+
+static GLdouble md [ 16 ] ;
+static GLfloat  mf [ 16 ] ;
+
+GLdouble *xglBuild1dv  ( GLdouble v ) {  d1[0] = v ; return  d1 ; }
+GLfloat  *xglBuild1fv  ( GLfloat  v ) {  f1[0] = v ; return  f1 ; }
+GLbyte   *xglBuild1bv  ( GLbyte   v ) {  b1[0] = v ; return  b1 ; }
+GLint    *xglBuild1iv  ( GLint    v ) {  i1[0] = v ; return  i1 ; }
+GLshort  *xglBuild1sv  ( GLshort  v ) {  s1[0] = v ; return  s1 ; }
+GLubyte  *xglBuild1ubv ( GLubyte  v ) { ub1[0] = v ; return ub1 ; }
+GLuint   *xglBuild1uiv ( GLuint   v ) { ui1[0] = v ; return ui1 ; }
+GLushort *xglBuild1usv ( GLushort v ) { us1[0] = v ; return us1 ; }
+
+GLdouble *xglBuild2dv  ( GLdouble v0, GLdouble v1 ) {  d2[0] = v0 ;  d2[1] = v1 ; return  d2 ; }
+GLfloat  *xglBuild2fv  ( GLfloat  v0, GLfloat  v1 ) {  f2[0] = v0 ;  f2[1] = v1 ; return  f2 ; }
+GLbyte   *xglBuild2bv  ( GLbyte   v0, GLbyte   v1 ) {  b2[0] = v0 ;  b2[1] = v1 ; return  b2 ; }
+GLint    *xglBuild2iv  ( GLint    v0, GLint    v1 ) {  i2[0] = v0 ;  i2[1] = v1 ; return  i2 ; }
+GLshort  *xglBuild2sv  ( GLshort  v0, GLshort  v1 ) {  s2[0] = v0 ;  s2[1] = v1 ; return  s2 ; }
+GLubyte  *xglBuild2ubv ( GLubyte  v0, GLubyte  v1 ) { ub2[0] = v0 ; ub2[1] = v1 ; return ub2 ; }
+GLuint   *xglBuild2uiv ( GLuint   v0, GLuint   v1 ) { ui2[0] = v0 ; ui2[1] = v1 ; return ui2 ; }
+GLushort *xglBuild2usv ( GLushort v0, GLushort v1 ) { us2[0] = v0 ; us2[1] = v1 ; return us2 ; }
+
+GLdouble *xglBuild3dv  ( GLdouble v0, GLdouble v1, GLdouble v2 ) {  d3[0] = v0 ;  d3[1] = v1 ;  d3[2] = v2 ; return  d3 ; }
+GLfloat  *xglBuild3fv  ( GLfloat  v0, GLfloat  v1, GLfloat  v2 ) {  f3[0] = v0 ;  f3[1] = v1 ;  f3[2] = v2 ; return  f3 ; }
+GLbyte   *xglBuild3bv  ( GLbyte   v0, GLbyte   v1, GLbyte   v2 ) {  b3[0] = v0 ;  b3[1] = v1 ;  b3[2] = v2 ; return  b3 ; }
+GLint    *xglBuild3iv  ( GLint    v0, GLint    v1, GLint    v2 ) {  i3[0] = v0 ;  i3[1] = v1 ;  i3[2] = v2 ; return  i3 ; }
+GLshort  *xglBuild3sv  ( GLshort  v0, GLshort  v1, GLshort  v2 ) {  s3[0] = v0 ;  s3[1] = v1 ;  s3[2] = v2 ; return  s3 ; }
+GLubyte  *xglBuild3ubv ( GLubyte  v0, GLubyte  v1, GLubyte  v2 ) { ub3[0] = v0 ; ub3[1] = v1 ; ub3[2] = v2 ; return ub3 ; }
+GLuint   *xglBuild3uiv ( GLuint   v0, GLuint   v1, GLuint   v2 ) { ui3[0] = v0 ; ui3[1] = v1 ; ui3[2] = v2 ; return ui3 ; }
+GLushort *xglBuild3usv ( GLushort v0, GLushort v1, GLushort v2 ) { us3[0] = v0 ; us3[1] = v1 ; us3[2] = v2 ; return us3 ; }
+
+
+GLdouble *xglBuild4dv  ( GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) {  d4[0] = v0 ;  d4[1] = v1 ;  d4[2] = v2 ;  d4[3] = v3 ; return  d4 ; }
+GLfloat  *xglBuild4fv  ( GLfloat  v0, GLfloat  v1, GLfloat  v2, GLfloat  v3 ) {  f4[0] = v0 ;  f4[1] = v1 ;  f4[2] = v2 ;  f4[3] = v3 ; return  f4 ; }
+GLbyte   *xglBuild4bv  ( GLbyte   v0, GLbyte   v1, GLbyte   v2, GLbyte   v3 ) {  b4[0] = v0 ;  b4[1] = v1 ;  b4[2] = v2 ;  b4[3] = v3 ; return  b4 ; }
+GLint    *xglBuild4iv  ( GLint    v0, GLint    v1, GLint    v2, GLint    v3 ) {  i4[0] = v0 ;  i4[1] = v1 ;  i4[2] = v2 ;  i4[3] = v3 ; return  i4 ; }
+GLshort  *xglBuild4sv  ( GLshort  v0, GLshort  v1, GLshort  v2, GLshort  v3 ) {  s4[0] = v0 ;  s4[1] = v1 ;  s4[2] = v2 ;  s4[3] = v3 ; return  s4 ; }
+GLubyte  *xglBuild4ubv ( GLubyte  v0, GLubyte  v1, GLubyte  v2, GLubyte  v3 ) { ub4[0] = v0 ; ub4[1] = v1 ; ub4[2] = v2 ; ub4[3] = v3 ; return ub4 ; }
+GLuint   *xglBuild4uiv ( GLuint   v0, GLuint   v1, GLuint   v2, GLuint   v3 ) { ui4[0] = v0 ; ui4[1] = v1 ; ui4[2] = v2 ; ui4[3] = v3 ; return ui4 ; }
+GLushort *xglBuild4usv ( GLushort v0, GLushort v1, GLushort v2, GLushort v3 ) { us4[0] = v0 ; us4[1] = v1 ; us4[2] = v2 ; us4[3] = v3 ; return us4 ; }
+
+GLdouble *xglBuildMatrixd ( GLdouble m0 , GLdouble m1 , GLdouble m2 , GLdouble m3 ,
+                            GLdouble m4 , GLdouble m5 , GLdouble m6 , GLdouble m7 ,
+                            GLdouble m8 , GLdouble m9 , GLdouble m10, GLdouble m11,
+                            GLdouble m12, GLdouble m13, GLdouble m14, GLdouble m15 )
+{
+  md[ 0] = m0  ; md[ 1] = m1  ; md[ 2] = m2  ; md[ 3] = m3  ;
+  md[ 4] = m4  ; md[ 5] = m5  ; md[ 6] = m6  ; md[ 7] = m7  ;
+  md[ 8] = m8  ; md[ 9] = m9  ; md[10] = m10 ; md[11] = m11 ;
+  md[12] = m12 ; md[13] = m13 ; md[14] = m14 ; md[15] = m15 ;
+
+  return md ;
+}
+
+
+GLfloat *xglBuildMatrixf ( GLfloat m0 , GLfloat m1 , GLfloat m2 , GLfloat m3 ,
+                           GLfloat m4 , GLfloat m5 , GLfloat m6 , GLfloat m7 ,
+                           GLfloat m8 , GLfloat m9 , GLfloat m10, GLfloat m11,
+                           GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15 )
+{
+  mf[ 0] = m0  ; mf[ 1] = m1  ; mf[ 2] = m2  ; mf[ 3] = m3  ;
+  mf[ 4] = m4  ; mf[ 5] = m5  ; mf[ 6] = m6  ; mf[ 7] = m7  ;
+  mf[ 8] = m8  ; mf[ 9] = m9  ; mf[10] = m10 ; mf[11] = m11 ;
+  mf[12] = m12 ; mf[13] = m13 ; mf[14] = m14 ; mf[15] = m15 ;
+
+  return mf ;
+}
+
@@ -0,0 +1,17 @@
+bin_PROGRAMS = example
+
+example_SOURCES = example.cxx
+
+example_LDADD = \
+	$(top_builddir)/Lib/Audio/src/libsl.a \
+	$(top_builddir)/Lib/Audio/src/libsm.a
+
+INCLUDES += -I$(top_builddir)/Lib/Audio/src
+
+if ENABLE_IRIX_AUDIO
+LIBS += -laudio
+endif
+
+if ENABLE_WIN32_AUDIO
+LIBS += -lwinmm
+endif
@@ -0,0 +1,89 @@
+
+
+#include "sl.h"
+#include "sm.h"
+#include <math.h>
+
+/*
+  Construct a sound scheduler and a mixer.
+*/
+
+slScheduler sched ( 8000 ) ;
+smMixer mixer ;
+
+int main ()
+{
+  mixer . setMasterVolume ( 30 ) ;
+  sched . setSafetyMargin ( 0.128 ) ;
+
+  /* Just for fun, let's make a one second synthetic engine sample... */
+
+  Uchar buffer [ 8000 ] ;
+
+  for ( int i = 0 ; i < 8000 ; i++ )
+  {
+    /* Sum some sin waves and convert to range 0..1 */
+
+    float level = ( sin ( (double) i * 2.0 * M_PI / (8000.0/ 50.0) ) +
+                    sin ( (double) i * 2.0 * M_PI / (8000.0/149.0) ) +
+                    sin ( (double) i * 2.0 * M_PI / (8000.0/152.0) ) +
+                    sin ( (double) i * 2.0 * M_PI / (8000.0/192.0) )
+                  ) / 8.0f + 0.5f ;
+
+    /* Convert to unsigned byte */
+
+    buffer [ i ] = (Uchar) ( level * 255.0 ) ;
+  }
+
+  /* Set up four samples and a loop */
+
+  slSample  *s = new slSample ( buffer, 8000 ) ;
+  slSample *s1 = new slSample ( "scream.ub", & sched ) ;
+  slSample *s2 = new slSample ( "zzap.wav" , & sched ) ;
+  slSample *s3 = new slSample ( "cuckoo.au", & sched ) ;
+  slSample *s4 = new slSample ( "wheeee.ub", & sched ) ;
+
+  /* Mess about with some of the samples... */
+
+  s1 -> adjustVolume ( 2.2  ) ;
+  s2 -> adjustVolume ( 0.5  ) ;
+  s3 -> adjustVolume ( 0.2  ) ;
+
+  /* Play the engine sample continuously. */
+
+  sched . loopSample ( s ) ;
+
+  int tim = 0 ;  /* My periodic event timer. */
+
+  while ( SL_TRUE )
+  {
+    tim++ ;  /* Time passes */
+
+    if ( tim % 200 == 0 ) sched.playSample ( s1 ) ;
+    if ( tim % 180 == 0 ) sched.playSample ( s2 ) ;
+    if ( tim % 150 == 0 ) sched.playSample ( s3 ) ;
+    if ( tim % 120 == 0 ) sched.playSample ( s4 ) ;
+
+    /*
+      For the sake of realism, I'll delay for 1/30th second to
+      simulate a graphics update process.
+    */
+
+#ifdef WIN32
+    Sleep ( 1000 / 30 ) ;      /* 30Hz */
+#elif defined(sgi)
+    sginap( 3 );               /* ARG */
+#else
+    usleep ( 1000000 / 30 ) ;  /* 30Hz */
+#endif
+
+    /*
+      This would normally be called just before the graphics buffer swap
+      - but it could be anywhere where it's guaranteed to get called
+      fairly often.
+    */
+
+    sched . update () ;
+  }
+}
+
@@ -1,19 +0,0 @@
-noinst_LIBRARIES = libAstro.a
-
-libAstro_a_SOURCES = \
-	celestialBody.cxx celestialBody.hxx \
-	jupiter.cxx jupiter.hxx \
-	mars.cxx mars.hxx \
-	mercury.cxx mercury.hxx \
-	moon.cxx moon.hxx \
-	neptune.cxx neptune.hxx \
-	pluto.hxx \
-	saturn.cxx saturn.hxx \
-	sky.cxx sky.hxx \
-	solarsystem.cxx solarsystem.hxx \
-	star.cxx star.hxx \
-	stars.cxx stars.hxx \
-	uranus.cxx uranus.hxx \
-	venus.cxx venus.hxx
-
-INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib -I$(top_builddir)/Simulator
@@ -1,178 +0,0 @@
-/**************************************************************************
- * celestialBody.cxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-
-#include <Debug/logstream.hxx>
-
-#ifdef FG_MATH_EXCEPTION_CLASH
-#  define exception c_exception
-#endif
-#include <math.h>
-
-#include "celestialBody.hxx"
-#include "star.hxx"
-
-
-/**************************************************************************
- * void CelestialBody::updatePosition(fgTIME *t, Star *ourSun)
- *
- * Basically, this member function provides a general interface for 
- * calculating the right ascension and declinaion. This function is 
- * used for calculating the planetary positions. For the planets, an 
- * overloaded member function is provided to additionally calculate the
- * planet's magnitude. 
- * The sun and moon have their own overloaded updatePosition member, as their
- * position is calculated an a slightly different manner.  
- *
- * arguments:
- * fgTIME t: provides the current time.
- * Star *ourSun: the sun's position is needed to convert heliocentric 
- *               coordinates into geocentric coordinates.
- *
- * return value: none
- *
- *************************************************************************/
-void CelestialBody::updatePosition(FGTime *t, Star *ourSun)
-{
-  double eccAnom, v, ecl, actTime, 
-    xv, yv, xh, yh, zh, xg, yg, zg, xe, ye, ze;
-
-  updateOrbElements(t);
-  actTime = fgCalcActTime(t);
-
-  // calcualate the angle bewteen ecliptic and equatorial coordinate system
-  ecl = DEG_TO_RAD * (23.4393 - 3.563E-7 *actTime);
-  
-  eccAnom = fgCalcEccAnom(M, e);  //calculate the eccentric anomaly
-  xv = a * (cos(eccAnom) - e);
-  yv = a * (sqrt (1.0 - e*e) * sin(eccAnom));
-  v = atan2(yv, xv);           // the planet's true anomaly
-  r = sqrt (xv*xv + yv*yv);    // the planet's distance
-  
-  // calculate the planet's position in 3D space
-  xh = r * (cos(N) * cos(v+w) - sin(N) * sin(v+w) * cos(i));
-  yh = r * (sin(N) * cos(v+w) + cos(N) * sin(v+w) * cos(i));
-  zh = r * (sin(v+w) * sin(i));
-
-  // calculate the ecliptic longitude and latitude
-  xg = xh + ourSun->getxs();
-  yg = yh + ourSun->getys();
-  zg = zh;
-
-  lonEcl = atan2(yh, xh);
-  latEcl = atan2(zh, sqrt(xh*xh+yh*yh));
-
-  xe = xg;
-  ye = yg * cos(ecl) - zg * sin(ecl);
-  ze = yg * sin(ecl) + zg * cos(ecl);
-  rightAscension = atan2(ye, xe);
-  declination = atan2(ze, sqrt(xe*xe + ye*ye));
-  FG_LOG(FG_GENERAL, FG_INFO, "Planet found at : " 
-	 << rightAscension << " (ra), " << declination << " (dec)" );
-
-  //calculate some variables specific to calculating the magnitude 
-  //of the planet
-  R = sqrt (xg*xg + yg*yg + zg*zg);
-  s = ourSun->getDistance();
-
-  // It is possible from these calculations for the argument to acos
-  // to exceed the valid range for acos(). So we do a little extra
-  // checking.
-
-  double tmp = (r*r + R*R - s*s) / (2*r*R);
-  if ( tmp > 1.0) { 
-      tmp = 1.0;
-  } else if ( tmp < -1.0) {
-      tmp = -1.0;
-  }
-
-  FV = RAD_TO_DEG * acos( tmp );
-};
-
-/****************************************************************************
- * double CelestialBody::fgCalcEccAnom(double M, double e)
- * this private member calculates the eccentric anomaly of a celestial body, 
- * given its mean anomaly and eccentricity.
- * 
- * -Mean anomaly: the approximate angle between the perihelion and the current
- *  position. this angle increases uniformly with time.
- *
- * True anomaly: the actual angle between perihelion and current position.
- *
- * Eccentric anomaly: this is an auxilary angle, used in calculating the true
- * anomaly from the mean anomaly.
- * 
- * -eccentricity. Indicates the amount in which the orbit deviates from a 
- *  circle (0 = circle, 0-1, is ellipse, 1 = parabola, > 1 = hyperbola).
- *
- * This function is also known as solveKeplersEquation()
- *
- * arguments: 
- * M: the mean anomaly
- * e: the eccentricity
- *
- * return value:
- * the eccentric anomaly
- *
- ****************************************************************************/
-double CelestialBody::fgCalcEccAnom(double M, double e)
-{
-  double 
-    eccAnom, E0, E1, diff;
-  
-  eccAnom = M + e * sin(M) * (1.0 + e * cos (M));
-  // iterate to achieve a greater precision for larger eccentricities 
-  if (e > 0.05)
-    {
-      E0 = eccAnom;
-      do
-	{
-	  E1 = E0 - (E0 - e * sin(E0) - M) / (1 - e *cos(E0));
-	  diff = fabs(E0 - E1);
-	  E0 = E1;
-	}
-      while (diff > (DEG_TO_RAD * 0.001));
-      return E0;
-    }
-  return eccAnom;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1,195 +0,0 @@
-/**************************************************************************
- * celestialBody.hxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-
-
-#ifndef _CELESTIALBODY_H_
-#define _CELESTIALBODY_H_
-
-#ifndef __cplusplus                                                          
-# error This library requires C++
-#endif                                   
-
-
-#include <Time/fg_time.hxx>
-#include <Include/fg_constants.h>
-
-class Star;
-
-class CelestialBody
-{
-protected:              // make the data protected, in order to give the inherited
-                        // classes direct access to the data
-  double NFirst;       	/* longitude of the ascending node first part */
-  double NSec;		/* longitude of the ascending node second part */
-  double iFirst;       	/* inclination to the ecliptic first part */
-  double iSec;		/* inclination to the ecliptic second part */
-  double wFirst;       	/* first part of argument of perihelion */
-  double wSec;		/* second part of argument of perihelion */
-  double aFirst;       	/* semimayor axis first part*/
-  double aSec;		/* semimayor axis second part */
-  double eFirst;       	/* eccentricity first part */
-  double eSec;		/* eccentricity second part */
-  double MFirst;       	/* Mean anomaly first part */
-  double MSec;		/* Mean anomaly second part */
-
-  double N, i, w, a, e, M; /* the resulting orbital elements, obtained from the former */
-
-  double rightAscension, declination;
-  double r, R, s, FV;
-  double magnitude;
-  double lonEcl, latEcl;
-
-  double fgCalcEccAnom(double M, double e);
-  double fgCalcActTime(FGTime *t);
-  void updateOrbElements(FGTime *t);
-
-public:
-  CelestialBody(double Nf, double Ns,
-		double If, double Is,
-		double wf, double ws,
-		double af, double as,
-		double ef, double es,
-		double Mf, double Ms, FGTime *t);
-  void getPos(double *ra, double *dec);
-  void getPos(double *ra, double *dec, double *magnitude);
-  double getLon();
-  double getLat(); 
-  void updatePosition(FGTime *t, Star *ourSun);
-};
-
-/*****************************************************************************
- * inline CelestialBody::CelestialBody
- * public constructor for a generic celestialBody object.
- * initializes the 6 primary orbital elements. The elements are:
- * N: longitude of the ascending node
- * i: inclination to the ecliptic
- * w: argument of perihelion
- * a: semi-major axis, or mean distance from the sun
- * e: eccenticity
- * M: mean anomaly
- * Each orbital element consists of a constant part and a variable part that 
- * gradually changes over time. 
- *
- * Argumetns:
- * the 13 arguments to the constructor constitute the first, constant 
- * ([NiwaeM]f) and the second variable ([NiwaeM]s) part of the orbital 
- * elements. The 13th argument is the current time. Note that the inclination
- * is written with a capital (If, Is), because 'if' is a reserved word in the 
- * C/C++ programming language.
- ***************************************************************************/ 
-inline CelestialBody::CelestialBody(double Nf, double Ns,
-				    double If, double Is,
-				    double wf, double ws,
-				    double af, double as,
-				    double ef, double es,
-				    double Mf, double Ms, FGTime *t)
-{
-  NFirst = Nf;     NSec = Ns;
-  iFirst = If;     iSec = Is;
-  wFirst = wf;     wSec = ws;
-  aFirst = af;     aSec = as;
-  eFirst = ef;     eSec = es;
-  MFirst = Mf;     MSec = Ms;
-  updateOrbElements(t);
-};
-
-/****************************************************************************
- * inline void CelestialBody::updateOrbElements(FGTime *t)
- * given the current time, this private member calculates the actual 
- * orbital elements
- *
- * Arguments: FGTime *t: the current time:
- *
- * return value: none
- ***************************************************************************/
-inline void CelestialBody::updateOrbElements(FGTime *t)
-{
-  double actTime = fgCalcActTime(t);
-   M = DEG_TO_RAD * (MFirst + (MSec * actTime));
-   w = DEG_TO_RAD * (wFirst + (wSec * actTime));
-   N = DEG_TO_RAD * (NFirst + (NSec * actTime));
-   i = DEG_TO_RAD * (iFirst + (iSec * actTime));
-   e = eFirst + (eSec * actTime);
-   a = aFirst + (aSec * actTime);
-}
-/*****************************************************************************
- * inline double CelestialBody::fgCalcActTime(FGTime *t)
- * this private member function returns the offset in days from the epoch for
- * wich the orbital elements are calculated (Jan, 1st, 2000).
- * 
- * Argument: the current time
- *
- * return value: the (fractional) number of days until Jan 1, 2000.
- ****************************************************************************/
-inline double CelestialBody::fgCalcActTime(FGTime *t)
-{
-  return (t->getMjd() - 36523.5);
-}
-
-/*****************************************************************************
- * inline void CelestialBody::getPos(double* ra, double* dec)
- * gives public access to Right Ascension and declination
- *
- ****************************************************************************/
-inline void CelestialBody::getPos(double* ra, double* dec)
-{
-  *ra  = rightAscension;
-  *dec = declination;
-}
-
-/*****************************************************************************
- * inline void CelestialBody::getPos(double* ra, double* dec, double* magnitude
- * gives public acces to the current Right ascension, declination, and 
- * magnitude
- ****************************************************************************/
-inline void CelestialBody::getPos(double* ra, double* dec, double* magn)
-{
-  *ra = rightAscension;
-  *dec = declination;
-  *magn = magnitude;
-}
-
-inline double CelestialBody::getLon()
-{
-  return lonEcl;
-}
-
-inline double CelestialBody::getLat()
-{
-  return latEcl;
-}
-
-#endif // _CELESTIALBODY_H_
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1,65 +0,0 @@
-/**************************************************************************
- * jupiter.cxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
-#include <math.h>
-
-#include "jupiter.hxx"
-
-/*************************************************************************
- * Jupiter::Jupiter(FGTime *t)
- * Public constructor for class Jupiter
- * Argument: The current time.
- * the hard coded orbital elements for Jupiter are passed to 
- * CelestialBody::CelestialBody();
- ************************************************************************/
-Jupiter::Jupiter(FGTime *t) :
-  CelestialBody(100.4542,  2.7685400E-5,	
-		1.3030,   -1.557E-7,
-		273.8777,  1.6450500E-5,
-		5.2025600, 0.000000,
-		0.048498,  4.469E-9,
-		19.89500,  0.08308530010, t)
-{
-}
-
-/*************************************************************************
- * void Jupiter::updatePosition(FGTime *t, Star *ourSun)
- * 
- * calculates the current position of Jupiter, by calling the base class,
- * CelestialBody::updatePosition(); The current magnitude is calculated using 
- * a Jupiter specific equation
- *************************************************************************/
-void Jupiter::updatePosition(FGTime *t, Star *ourSun)
-{
-  CelestialBody::updatePosition(t, ourSun);
-  magnitude = -9.25 + 5*log10( r*R ) + 0.014 * FV;
-}
-
-
-
-
@@ -1,38 +0,0 @@
-/**************************************************************************
- * jupiter.hxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-#ifndef _JUPITER_HXX_
-#define _JUPITER_HXX_
-
-#include <Time/fg_time.hxx>
-#include "celestialBody.hxx"
-#include "star.hxx"
-
-class Jupiter : public CelestialBody
-{
-public:
-  Jupiter (FGTime *t);
-  void updatePosition(FGTime *t, Star *ourSun);
-};
-
-#endif // _JUPITER_HXX_
@@ -1,59 +0,0 @@
-/**************************************************************************
- * mars.cxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
-#include <math.h>
-
-#include "mars.hxx"
-
-/*************************************************************************
- * Mars::Mars(FGTime *t)
- * Public constructor for class Mars
- * Argument: The current time.
- * the hard coded orbital elements for Mars are passed to 
- * CelestialBody::CelestialBody();
- ************************************************************************/
-Mars::Mars(FGTime *t) :
-  CelestialBody(49.55740,  2.1108100E-5,
-		1.8497,   -1.78E-8,
-		286.5016,  2.9296100E-5,
-		1.5236880, 0.000000,
-		0.093405,  2.516E-9,
-		18.60210,  0.52402077660, t)
-{
-}
-/*************************************************************************
- * void Mars::updatePosition(FGTime *t, Star *ourSun)
- * 
- * calculates the current position of Mars, by calling the base class,
- * CelestialBody::updatePosition(); The current magnitude is calculated using 
- * a Mars specific equation
- *************************************************************************/
-void Mars::updatePosition(FGTime *t, Star *ourSun)
-{
-  CelestialBody::updatePosition(t, ourSun);
-  magnitude = -1.51 + 5*log10( r*R ) + 0.016 * FV;
-}
@@ -1,38 +0,0 @@
-/**************************************************************************
- * mars.hxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-#ifndef _MARS_HXX_
-#define _MARS_HXX_
-
-#include <Time/fg_time.hxx>
-#include "celestialBody.hxx"
-#include "star.hxx"
-
-class Mars : public CelestialBody
-{
-public:
-  Mars ( FGTime *t);
-  void updatePosition(FGTime *t, Star *ourSun);
-};
-
-#endif // _MARS_HXX_
@@ -1,61 +0,0 @@
-/**************************************************************************
- * mercury.cxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
-#include <math.h>
-
-#include "mercury.hxx"
-
-/*************************************************************************
- * Mercury::Mercury(FGTime *t)
- * Public constructor for class Mercury
- * Argument: The current time.
- * the hard coded orbital elements for Mercury are passed to 
- * CelestialBody::CelestialBody();
- ************************************************************************/
-Mercury::Mercury(FGTime *t) :
-  CelestialBody (48.33130,   3.2458700E-5,
-                  7.0047,    5.00E-8,
-                  29.12410,  1.0144400E-5,
-                  0.3870980, 0.000000,
-                  0.205635,  5.59E-10,
-                  168.6562,  4.09233443680, t)
-{
-}
-/*************************************************************************
- * void Mercury::updatePosition(FGTime *t, Star *ourSun)
- * 
- * calculates the current position of Mercury, by calling the base class,
- * CelestialBody::updatePosition(); The current magnitude is calculated using 
- * a Mercury specific equation
- *************************************************************************/
-void Mercury::updatePosition(FGTime *t, Star *ourSun)
-{
-  CelestialBody::updatePosition(t, ourSun);
-  magnitude = -0.36 + 5*log10( r*R ) + 0.027 * FV + 2.2E-13 * pow(FV, 6); 
-}
-
-
@@ -1,38 +0,0 @@
-/**************************************************************************
- * mercury.hxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-#ifndef _MERCURY_HXX_
-#define _MERCURY_HXX_
-
-#include <Time/fg_time.hxx>
-#include "celestialBody.hxx"
-#include "star.hxx"
-
-class Mercury : public CelestialBody
-{
-public:
-  Mercury ( FGTime *t);
-  void updatePosition(FGTime *t, Star* ourSun);
-};
-
-#endif // _MERURY_HXX_
@@ -1,401 +0,0 @@
-/**************************************************************************
- * moon.cxx
- * Written by Durk Talsma. Originally started October 1997, for distribution  
- * with the FlightGear project. Version 2 was written in August and 
- * September 1998. This code is based upon algorithms and data kindly 
- * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id$
- **************************************************************************/
-
-
-#include <string.h>
-
-#include <Debug/logstream.hxx>
-#include <Main/options.hxx>
-#include <Misc/fgpath.hxx>
-#include <Objects/texload.h>
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
-#include <math.h>
-
-#include <FDM/flight.hxx>
-
-#include "moon.hxx"
-
-/*************************************************************************
- * Moon::Moon(FGTime *t)
- * Public constructor for class Moon. Initializes the orbital elements and 
- * sets up the moon texture.
- * Argument: The current time.
- * the hard coded orbital elements for Moon are passed to 
- * CelestialBody::CelestialBody();
- ************************************************************************/
-Moon::Moon(FGTime *t) :
-  CelestialBody(125.1228, -0.0529538083,
-		5.1454,    0.00000,
-		318.0634,  0.1643573223,
-		60.266600, 0.000000,
-		0.054900,  0.000000,
-		115.3654,  13.0649929509, t)
-{
-  int width, height;
-  
-  FG_LOG( FG_GENERAL, FG_INFO, "Initializing Moon Texture");
-#ifdef GL_VERSION_1_1
-  xglGenTextures(1, &moon_texid);
-  xglBindTexture(GL_TEXTURE_2D, moon_texid);
-#elif GL_EXT_texture_object
-  xglGenTexturesEXT(1, &moon_texid);
-  xglBindTextureEXT(GL_TEXTURE_2D, moon_texid);
-#else
-#  error port me
-#endif
-
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-  // load in the texture data
-  FGPath tpath( current_options.get_fg_root() );
-  tpath.append( "Textures" );
-  tpath.append( "moon.rgb" );
-
-  if ( (moon_texbuf = read_rgb_texture(tpath.c_str(), &width, &height)) 
-       == NULL )
-  {
-    // Try compressed
-    FGPath fg_tpath = tpath;
-    fg_tpath.append( ".gz" );
-    if ( (moon_texbuf = read_rgb_texture(fg_tpath.c_str(), &width, &height)) 
-	 == NULL )
-    {
-	FG_LOG( FG_GENERAL, FG_ALERT, 
-		"Error in loading moon texture " << tpath.str() );
-	exit(-1);
-    } 
-  } 
-
-  glTexImage2D( GL_TEXTURE_2D,
-		0,
-		GL_RGB,
-		256, 256,
-		0,
-		GL_RGB, GL_UNSIGNED_BYTE,
-		moon_texbuf);
-
-  // setup the halo texture
-  FG_LOG( FG_GENERAL, FG_INFO, "Initializing Moon Texture");
-#ifdef GL_VERSION_1_1
-  xglGenTextures(1, &moon_halotexid);
-  xglBindTexture(GL_TEXTURE_2D, moon_halotexid);
-#elif GL_EXT_texture_object
-  xglGenTexturesEXT(1, &moon_halotexid);
-  xglBindTextureEXT(GL_TEXTURE_2D, moon_halotexid);
-#else
-#  error port me
-#endif
-
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  setHalo();
-  glTexImage2D( GL_TEXTURE_2D,
-		0,
-		GL_RGBA,
-		256, 256,
-		0,
-		GL_RGBA, GL_UNSIGNED_BYTE,
-		moon_halotexbuf);
-  moonObject = gluNewQuadric();
-}
-
-Moon::~Moon()
-{
-  //delete moonObject;
-  delete moon_texbuf;
-  delete moon_halotexbuf;
-}
-
-
-static int texWidth = 256;	/* 64x64 is plenty */
-
-void Moon::setHalo()
-{
-  int texSize;
-  //void *textureBuf;
-  GLubyte *p;
-  int i,j;
-  double radius;
-  
-  texSize = texWidth*texWidth;
-  
-  moon_halotexbuf = new GLubyte[texSize*4];
-  if (!moon_halotexbuf) 
-    return;  // Ugly!
-  
-  p = moon_halotexbuf;
-  
-  radius = (double)(texWidth / 2);
-  
-  for (i=0; i < texWidth; i++) {
-    for (j=0; j < texWidth; j++) {
-      double x, y, d;
-	    
-      x = fabs((double)(i - (texWidth / 2)));
-      y = fabs((double)(j - (texWidth / 2)));
-
-      d = sqrt((x * x) + (y * y));
-      if (d < radius) 
-	{
-	  double t = 1.0 - (d / radius); // t is 1.0 at center, 0.0 at edge */
-	  // inverse square looks nice 
-	  *p = (int)((double)0xff * (t * t));
-	  *(p+1) = (int)((double) 0xff * (t*t));
-	  *(p+2) = (int)((double) 0xff * (t*t));
-	  *(p+3) = 0x11;
-	} 
-      else
-	{
-	  *p = 0x00;
-	  *(p+1) = 0x00;
-	  *(p+2) = 0x00;
-	  *(p+3) = 0x11;
-	}
-      p += 4;
-    }
-  }
-  //gluBuild2DMipmaps(GL_TEXTURE_2D, 1, texWidth, texWidth, 
-  //	    GL_LUMINANCE,
-  //	    GL_UNSIGNED_BYTE, textureBuf);
-  //free(textureBuf);
-}
-
-
-/*****************************************************************************
- * void Moon::updatePosition(FGTime *t, Star *ourSun)
- * this member function calculates the actual topocentric position (i.e.) 
- * the position of the moon as seen from the current position on the surface
- * of the moon. 
- ****************************************************************************/
-void Moon::updatePosition(FGTime *t, Star *ourSun)
-{
-  double 
-    eccAnom, ecl, actTime,
-    xv, yv, v, r, xh, yh, zh, xg, yg, zg, xe, ye, ze,
-    Ls, Lm, D, F, mpar, gclat, rho, HA, g,
-    geoRa, geoDec;
-  
-  fgAIRCRAFT *air;
-  FGInterface *f;
-
-  air = &current_aircraft;
-  f = air->fdm_state;
- 
-  updateOrbElements(t);
-  actTime = fgCalcActTime(t);
-
-  // calculate the angle between ecliptic and equatorial coordinate system
-  // in Radians
-  ecl = ((DEG_TO_RAD * 23.4393) - (DEG_TO_RAD * 3.563E-7) * actTime);  
-  eccAnom = fgCalcEccAnom(M, e);  // Calculate the eccentric anomaly
-  xv = a * (cos(eccAnom) - e);
-  yv = a * (sqrt(1.0 - e*e) * sin(eccAnom));
-  v = atan2(yv, xv);               // the moon's true anomaly
-  r = sqrt (xv*xv + yv*yv);       // and its distance
-  
-  // estimate the geocentric rectangular coordinates here
-  xh = r * (cos(N) * cos (v+w) - sin (N) * sin(v+w) * cos(i));
-  yh = r * (sin(N) * cos (v+w) + cos (N) * sin(v+w) * cos(i));
-  zh = r * (sin(v+w) * sin(i));
-
-  // calculate the ecliptic latitude and longitude here
-  lonEcl = atan2 (yh, xh);
-  latEcl = atan2(zh, sqrt(xh*xh + yh*yh));
-
-  /* Calculate a number of perturbatioin, i.e. disturbances caused by the 
-   * gravitational infuence of the sun and the other major planets.
-   * The largest of these even have a name */
-  Ls = ourSun->getM() + ourSun->getw();
-  Lm = M + w + N;
-  D = Lm - Ls;
-  F = Lm - N;
-  
-  lonEcl += DEG_TO_RAD * (-1.274 * sin (M - 2*D)
-			  +0.658 * sin (2*D)
-			  -0.186 * sin(ourSun->getM())
-			  -0.059 * sin(2*M - 2*D)
-			  -0.057 * sin(M - 2*D + ourSun->getM())
-			  +0.053 * sin(M + 2*D)
-			  +0.046 * sin(2*D - ourSun->getM())
-			  +0.041 * sin(M - ourSun->getM())
-			  -0.035 * sin(D)
-			  -0.031 * sin(M + ourSun->getM())
-			  -0.015 * sin(2*F - 2*D)
-			  +0.011 * sin(M - 4*D)
-			  );
-  latEcl += DEG_TO_RAD * (-0.173 * sin(F-2*D)
-			  -0.055 * sin(M - F - 2*D)
-			  -0.046 * sin(M + F - 2*D)
-			  +0.033 * sin(F + 2*D)
-			  +0.017 * sin(2*M + F)
-			  );
-  r += (-0.58 * cos(M - 2*D)
-	-0.46 * cos(2*D)
-	);
-  FG_LOG(FG_GENERAL, FG_INFO, "Running moon update");
-  xg = r * cos(lonEcl) * cos(latEcl);
-  yg = r * sin(lonEcl) * cos(latEcl);
-  zg = r *               sin(latEcl);
-  
-  xe = xg;
-  ye = yg * cos(ecl) -zg * sin(ecl);
-  ze = yg * sin(ecl) +zg * cos(ecl);
-
-  geoRa  = atan2(ye, xe);
-  geoDec = atan2(ze, sqrt(xe*xe + ye*ye));
-
-  /* FG_LOG( FG_GENERAL, FG_INFO, 
-	  "(geocentric) geoRa = (" << (RAD_TO_DEG * geoRa) 
-	  << "), geoDec= (" << (RAD_TO_DEG * geoDec) << ")" ); */
-
-
-  // Given the moon's geocentric ra and dec, calculate its 
-  // topocentric ra and dec. i.e. the position as seen from the
-  // surface of the earth, instead of the center of the earth
-
-  // First calculate the moon's parrallax, that is, the apparent size of the 
-  // (equatorial) radius of the earth, as seen from the moon 
-  mpar = asin ( 1 / r);
-  // FG_LOG( FG_GENERAL, FG_INFO, "r = " << r << " mpar = " << mpar );
-  // FG_LOG( FG_GENERAL, FG_INFO, "lat = " << f->get_Latitude() );
-
-  gclat = f->get_Latitude() - 0.003358 * 
-      sin (2 * DEG_TO_RAD * f->get_Latitude() );
-  // FG_LOG( FG_GENERAL, FG_INFO, "gclat = " << gclat );
-
-  rho = 0.99883 + 0.00167 * cos(2 * DEG_TO_RAD * f->get_Latitude());
-  // FG_LOG( FG_GENERAL, FG_INFO, "rho = " << rho );
-  
-  if (geoRa < 0)
-    geoRa += (2*FG_PI);
-  
-  HA = t->getLst() - (3.8197186 * geoRa);
-  /* FG_LOG( FG_GENERAL, FG_INFO, "t->getLst() = " << t->getLst() 
-	  << " HA = " << HA ); */
-
-  g = atan (tan(gclat) / cos ((HA / 3.8197186)));
-  // FG_LOG( FG_GENERAL, FG_INFO, "g = " << g );
-
-  rightAscension = geoRa - mpar * rho * cos(gclat) * sin(HA) / cos (geoDec);
-  declination = geoDec - mpar * rho * sin (gclat) * sin (g - geoDec) / sin(g);
-
-  /* FG_LOG( FG_GENERAL, FG_INFO, 
-	  "Ra = (" << (RAD_TO_DEG *rightAscension) 
-	  << "), Dec= (" << (RAD_TO_DEG *declination) << ")" ); */
-}
-
-
-/************************************************************************
- * void Moon::newImage()
- *
- * This function regenerates a new visual image of the moon, which is added to
- * solarSystem display list.
- *
- * Arguments: Right Ascension and declination
- *
- * return value: none
- **************************************************************************/
-void Moon::newImage()
-{
-  fgLIGHT *l = &cur_light_params;
-  float moon_angle = l->moon_angle;
-  
-  /*double x_2, x_4, x_8, x_10;
-  GLfloat ambient;
-  GLfloat amb[4];*/
-  int moonSize = 550;
-
-  GLfloat moonColor[4] = {0.85, 0.75, 0.35, 1.0};
-  GLfloat black[4] = {0.0, 0.0, 0.0, 1.0};
-  GLfloat white[4] = {1.0, 1.0, 1.0, 0.0};
-  
-  if( moon_angle*RAD_TO_DEG < 100 ) 
-    {
-      FG_LOG( FG_ASTRO, FG_INFO, "Generating Moon Image" );
-
-      xglPushMatrix();
-      {
-	xglRotatef(((RAD_TO_DEG * rightAscension)- 90.0), 0.0, 0.0, 1.0);
-	xglRotatef((RAD_TO_DEG * declination), 1.0, 0.0, 0.0);
-	
-	FG_LOG( FG_GENERAL, FG_INFO, 
-		"Ra = (" << (RAD_TO_DEG *rightAscension) 
-		<< "), Dec= (" << (RAD_TO_DEG *declination) << ")" );
-	xglTranslatef(0.0, 60000.0, 0.0);
-	glEnable(GL_BLEND);	// BLEND ENABLED
-
-	// Draw the halo...
-	if (current_options.get_textures())
-	  {
-	    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-	    glEnable(GL_TEXTURE_2D); // TEXTURE ENABLED
-	    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);  
-	    glBindTexture(GL_TEXTURE_2D, moon_halotexid);
-	  
-	    glBegin(GL_QUADS);
-	    glTexCoord2f(0.0f, 0.0f); glVertex3f(-5000, 0.0, -5000);
-	    glTexCoord2f(1.0f, 0.0f); glVertex3f( 5000, 0.0, -5000);
-	    glTexCoord2f(1.0f, 1.0f); glVertex3f( 5000, 0.0,  5000);
-	    glTexCoord2f(0.0f, 1.0f); glVertex3f(-5000, 0.0,  5000);
-	    glEnd();
-	  }
-	
-	xglEnable(GL_LIGHTING);	// LIGHTING ENABLED
-	xglEnable( GL_LIGHT0 );
-	// set lighting parameters
-	xglLightfv(GL_LIGHT0, GL_AMBIENT, white );
-	xglLightfv(GL_LIGHT0, GL_DIFFUSE, white );
-	// Enable( GL_CULL_FACE );
-	xglMaterialfv(GL_FRONT, GL_AMBIENT, black);
-	xglMaterialfv(GL_FRONT, GL_DIFFUSE, moonColor); 
-	//glEnable(GL_TEXTURE_2D);
-	
-	glBlendFunc(GL_ONE, GL_ONE);
-	
-	//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
-	// Draw the moon-proper
-	
-	if (current_options.get_textures())
-	  {
-	    glBindTexture(GL_TEXTURE_2D, moon_texid);                         
-	    gluQuadricTexture(moonObject, GL_TRUE );
-	  }
-	gluSphere(moonObject,  moonSize, 12, 12 );
-	glDisable(GL_TEXTURE_2D); // TEXTURE DISABLED
-	glDisable(GL_BLEND);	// BLEND DISABLED
-      }
-      xglPopMatrix();
-      glDisable(GL_LIGHTING);	// Lighting Disabled.
-      
-    }
-  else
-    {
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
curt	2c920ae1df	Added is_open() so we can check if the open() succeeded.	1999-03-27 14:04:25 +00:00
curt	bbde3b36bf	Elimitated some const warnings from the compiler.	1999-03-27 05:34:05 +00:00
curt	88a016c516	Minor optimization tweaks.	1999-03-25 19:02:28 +00:00
curt	22d4058564	Jettisoned old bucketutils.[ch] for newbucket.[ch]xx	1999-03-25 19:01:47 +00:00
curt	79e6c529ea	MSVC++ portability tweaks contributed by Bernie Bright. Added using std::ostream declaration. Added forward declarations to work around a MSVC bug.	1999-03-15 17:58:41 +00:00
curt	7b22b8cd92	Moved to math subdirectory.	1999-03-13 17:34:44 +00:00
curt	bc2ae82e81	Added some informational methods.	1999-03-12 22:51:18 +00:00
curt	764f4037b0	Tweak for native SGI compilers.	1999-03-08 22:00:12 +00:00
curt	a60454a786	Tweaks for compiling with native SGI compilers.	1999-03-02 01:01:42 +00:00
curt	d136ad3e57	Added initial support for native SGI compilers.	1999-02-26 22:07:53 +00:00
curt	739588f9c3	Renamed bucketutils.c -> bucketutils.cxx	1999-02-17 20:52:02 +00:00
curt	505de4703b	Added a routine to calculate the offset in bucket units between two buckets.	1999-02-11 01:09:33 +00:00
curt	236a1f2a2d	Added a FG_CLIPPER debug type for the polygon clipper lib.	1999-02-09 00:08:48 +00:00
curt	91efc5ad87	Added a new "newbucket.[ch]xx" FGBucket class to replace the old fgBUCKET struct and C routines. This FGBucket class adjusts the tile width towards the poles to ensure the tiles are at least 8 miles wide.	1999-02-08 23:52:13 +00:00
curt	123c816048	MSVC++ portability changes by Bernie Bright: Lib/Serial/serial.[ch]xx: Initial Windows support - incomplete. Simulator/Astro/stars.cxx: typo? included <stdio> instead of <cstdio> Simulator/Cockpit/hud.cxx: Added Standard headers Simulator/Cockpit/panel.cxx: Redefinition of default parameter Simulator/Flight/flight.cxx: Replaced cout with FG_LOG. Deleted <stdio.h> Simulator/Main/fg_init.cxx: Simulator/Main/GLUTmain.cxx: Simulator/Main/options.hxx: Shuffled <fg_serial.hxx> dependency Simulator/Objects/material.hxx: Simulator/Time/timestamp.hxx: VC++ friend kludge Simulator/Scenery/tile.[ch]xx: Fixed using std::X declarations Simulator/Main/views.hxx: Added a constant	1999-02-02 20:13:23 +00:00
curt	fab6d05157	Optimizations from Norman Vine.	1999-02-01 21:08:28 +00:00
curt	3240464c7c	Portability tweaks by Bernie Bright.	1999-01-27 04:46:14 +00:00
curt	a2ffd27b7c	Moved DEM/ to the Tools/ subdir.	1999-01-27 04:45:56 +00:00
curt	af6c921757	Tweaked FDM interface. Testing check sum support for NMEA serial output.	1999-01-20 13:42:21 +00:00
curt	180e2188ba	MacOS portability changes contributed by "Robert Puyol" <puyol@abvent.fr>	1999-01-19 20:56:53 +00:00
curt	23fbd5919f	Portability updates by Bernie Bright.	1999-01-19 20:53:34 +00:00
curt	8aec98017a	Portability updates contributed by Bernie Bright.	1999-01-19 20:41:46 +00:00
curt	9b4fe7d92d	Removed gpc from Libs since this is not "free ware" and the author has explicitely refused our request to distribute source code for this library with Flight Gear.	1999-01-19 17:50:36 +00:00
curt	99f11a01fc	Use C++ style comments.	1998-12-09 18:48:08 +00:00
curt	b3eacb19f6	Portability improvements.	1998-12-07 21:10:26 +00:00
curt	f12840a72e	Improvements to take advantage of memory portability changes.	1998-12-07 21:09:52 +00:00
curt	f472bc563d	Added a const in a couple places to get rid of annoying compiler warnings.	1998-12-07 21:08:01 +00:00
curt	3e05a5780d	Tweak for SGI portability.	1998-12-04 01:24:35 +00:00
curt	2454f8d269	tweak for un portability.	1998-12-03 01:11:56 +00:00
curt	b4a913e339	Having the class destructor close the fd was a bad idea ... especially if you ever make a copy of the instance and then subsequently destroy either. close_port() is now a separate member function.	1998-11-30 17:15:29 +00:00
curt	b82aef65e5	Remove call to cfmakeraw()	1998-11-25 01:33:23 +00:00
curt	3730ce404f	Cygnus tools compatibility tweaks.	1998-11-23 21:47:00 +00:00
curt	d7748704d7	Borland portability tweaks.	1998-11-23 21:46:36 +00:00
curt	1690f5475d	Add bucketutils.hxx to source list.	1998-11-23 21:46:13 +00:00
curt	a644bd2b03	Patch in fgGeoc2Geod() to avoid a floating explosion. point3d.hxx include math.h for FreeBSD	1998-11-20 01:00:36 +00:00
curt	62ca2e0227	FreeBSD support.	1998-11-20 00:59:23 +00:00
curt	d56289f897	port configuration tweaks & experiments.	1998-11-19 13:52:54 +00:00
curt	aa02e72829	Updates ...	1998-11-19 03:35:43 +00:00
curt	a878570a8d	Added an FG_SERIAL type to the FG_LOG macro.	1998-11-16 13:57:04 +00:00
curt	54352225f1	Added the Serial subdirectory	1998-11-16 13:56:45 +00:00
curt	0b7d4c8c1e	Initial revision.	1998-11-16 13:53:01 +00:00
curt	2091bf2144	Check for domain error in fgGeoctoGeod()	1998-11-11 00:18:36 +00:00
curt	0fec7b2599	Initial revision.	1998-11-09 23:42:12 +00:00
curt	74d314558c	Enable release builds using the --without-logging option to the configure script. Also a couple log message cleanups, plus some C to C++ comment conversion.	1998-11-07 19:07:02 +00:00
curt	4fb45c4783	Initial revision.	1998-11-06 21:20:41 +00:00
curt	6816ecb3ea	Converted to new logstream debugging facility. This allows release builds with no messages at all (and no performance impact) by using the -DFG_NDEBUG flag.	1998-11-06 21:17:23 +00:00
curt	6766825159	More portability improvements by Bernie Bright.	1998-11-06 14:05:12 +00:00
curt	3e63d6ca5d	Additional win32 support.	1998-11-02 18:28:31 +00:00
curt	6ca9596807	Check for __CYGWIN__ (b20) as well as __CYGWIN32__ (pre b20 compilers) Other misc. tweaks.	1998-11-02 18:25:32 +00:00
curt	5695fc84e1	Tweak for building with latest egcs.	1998-10-27 02:14:16 +00:00
curt	2aea6362db	Added point3d.hxx to the list of source files.	1998-10-22 21:59:44 +00:00
curt	bb70329c25	Tweaks from Bernie Bright.	1998-10-20 18:21:49 +00:00
curt	75bc07dc42	Point3D tweaks.	1998-10-18 01:17:11 +00:00
curt	bac27f1ce3	c++-ifying.	1998-10-16 23:36:36 +00:00
curt	787591dd79	Renamed .c -> .h so we can start adding c++ supporting routines.	1998-10-16 19:30:37 +00:00
curt	c7c353df05	C++-ified the comments.	1998-10-16 19:30:07 +00:00
curt	8470a9eda6	Remove leading _ from a couple defines.	1998-10-16 00:50:56 +00:00
curt	c5adb85741	Added point3d.hxx to replace cheezy fgPoint3d struct.	1998-10-16 00:50:29 +00:00
curt	2f9619f02a	More portability changes to help with windoze compilation problems.	1998-10-13 00:10:06 +00:00
curt	11cab90ce2	Udates from Steve.	1998-10-02 21:35:09 +00:00
curt	9ae48c2d7d	added a working() method.	1998-09-29 14:54:57 +00:00
curt	00fc8205da	Miscellaneous fixes under Steve's direction.	1998-09-29 02:00:38 +00:00
curt	62e85640da	Tweaked the example a bit.	1998-09-25 16:01:19 +00:00
curt	1b99b2a25d	Incorporated Steve's latest version of his audio library. This version allows pitch and volume changes so we should be able tie this to the throttle now.	1998-09-24 19:36:25 +00:00
curt	605ad52197	Additional enhancements.	1998-09-24 15:22:17 +00:00
curt	af80c5e018	Temporary destructor patch until Steve can release next version of PUI.	1998-09-15 02:10:03 +00:00
curt	18ac42b2e4	Tweaked compiled vs. lib vs. distributed file lists.	1998-09-08 21:39:34 +00:00
curt	9ea57fcc30	Fixes by Charlie Hotchkiss.	1998-09-08 21:39:07 +00:00
curt	7c27474164	Removed an extraneous extern "C" ...	1998-09-03 21:24:36 +00:00
curt	afdee14332	Tweaks for final 0.53	1998-09-02 21:30:58 +00:00
curt	7f5f12d37a	Initial revision.	1998-09-01 19:06:28 +00:00
curt	cea0df71f8	Added a Lib/Misc/ subdirectory.	1998-09-01 18:59:19 +00:00
curt	aef484d5fc	Various "inline" code optimizations contributed by Norman Vine.	1998-08-24 20:04:08 +00:00
curt	dacc051a57	Attempting to iron out seg faults and crashes. Did some shuffling to fix a initialization order problem between view position, scenery elevation.	1998-08-22 14:49:54 +00:00
curt	e111f530c3	Added Lib/gpc (generic polygon clipping library)	1998-08-22 01:18:27 +00:00
curt	c00ca055bc	cosmetic ...	1998-08-06 12:42:40 +00:00
curt	305589cd01	Removed zlib support.	1998-07-30 23:42:14 +00:00
curt	6610244275	removed libtool support.	1998-07-30 23:41:43 +00:00
curt	e462e64d42	Added Irix audio support.	1998-07-30 23:41:23 +00:00
curt	39521df546	Version 1.1.3	1998-07-24 21:35:29 +00:00
curt	6dd8a1525c	fgPointLine() rewritten into fgPointLineSquared() ... this ultimately saves us from doing a sqrt().	1998-07-24 21:34:38 +00:00
curt	fca7a8fa47	Initial revision.	1998-07-16 17:48:11 +00:00
curt	1175179da1	HAVE_AUDIO_SUPPORT -> ENABLE_AUDIO_SUPPORT	1998-07-16 17:29:12 +00:00
curt	06ab581edb	Incorporated next version of PUI.	1998-07-13 20:59:34 +00:00
curt	dbcecbd3b8	polar3d.[ch] renamed to polar3d.[ch]xx, vector.[ch] renamed to vector.[ch]xx Updated fg_geodesy comments to reflect that routines expect and produce meters.	1998-07-08 14:40:07 +00:00
curt	4205c0a38d	typedef'd struct fgBUCKET.	1998-07-04 00:46:47 +00:00
curt	a76904c314	Added #ifdef HAVE_CONFIG_H #include <config.h> #endif to get WIN32 definition.	1998-07-03 11:54:50 +00:00
curt	529ca14534	New version from Steve.	1998-06-17 21:32:42 +00:00
curt	7423077f95	Refine conditional audio compilation.	1998-06-17 21:31:45 +00:00
curt	f116ee7802	Pui -> PUI.	1998-06-12 14:26:19 +00:00
curt	09cf8c001e	Renamed Pui -> PUI.	1998-06-12 01:05:51 +00:00
curt	cfe0e18e4e	Initial revision.	1998-06-12 01:04:52 +00:00
curt	2caad4a27b	Added Pui subdirectory.	1998-06-12 00:53:47 +00:00
curt	b5e7938ebe	Added a Lib/Audio for Steve Baker's sound library.	1998-06-03 00:42:40 +00:00
curt	bd3e280fe5	initial checkin of notify	1998-06-02 21:42:22 +00:00
curt	39164d1438	initial checkin of modules	1998-06-02 21:42:22 +00:00
curt	a9c068ae3b	initial checkin of cvswrappers	1998-06-02 21:42:22 +00:00
curt	6c7856549b	initial checkin of taginfo	1998-06-02 21:42:21 +00:00
curt	d85cbc7b61	initial checkin of rcsinfo	1998-06-02 21:42:21 +00:00
curt	d8cbac4576	initial checkin of loginfo	1998-06-02 21:42:21 +00:00
curt	c0874a000e	initial checkin of editinfo	1998-06-02 21:42:21 +00:00
curt	e317a39b2d	initial checkin of commitinfo	1998-06-02 21:42:21 +00:00
curt	61d4bd8adf	initial checkin of checkoutlist	1998-06-02 21:42:21 +00:00
curt	a8deedaa66	Rewrote a slightly ambiguous code fragment (contributed by Charlie Hotchkiss)	1998-06-01 17:49:44 +00:00
curt	15790ef4b4	Borland C++ fixes from the zlib author. A new version is due out soon.	1998-05-29 20:30:11 +00:00
curt	8cf618ea75	Removed derived files "Makefile.in" from version control.	1998-05-23 14:31:48 +00:00
curt	5a81c9ecf0	Derived file "Makefile.in" removed from version control.	1998-05-23 14:18:22 +00:00
curt	4ccc2b3cfc	Small tweak for correct win32 compiling.	1998-05-20 20:50:28 +00:00
curt	ff8845de52	Better handling of WIN32 environments.	1998-05-13 18:24:49 +00:00
curt	e4d4a2d8eb	Wrapped zlib calls so zlib can be optionally disabled.	1998-05-13 18:24:25 +00:00
curt	5a2a23cc2d	Added an "#include <config.h>" and "#include <windows.h>"	1998-05-11 18:04:06 +00:00
curt	8a233ddfbb	Moved the extern "C" { } until after all the includes have been done.	1998-05-07 23:20:45 +00:00
curt	2b40dc133d	Added a blank formating line!	1998-05-07 23:04:28 +00:00
curt	b26263c62d	Added an entry for AUTOPILOT.	1998-05-07 23:03:54 +00:00
curt	2df317eb49	Commented out a debugging printf.	1998-05-03 00:45:49 +00:00
curt	5eef0e61ba	polar.[ch] renamed to polar3d.[ch]	1998-05-02 01:50:09 +00:00
curt	021558d6dd	Edited cvs log messages in source files ... bad bad bad!	1998-04-25 22:06:22 +00:00
curt	7a6cab8381	Changed "r" to "rb" in gzopen() options. This fixes bad behavior in win32.	1998-04-25 15:05:01 +00:00
curt	1fcb70e553	Wrapped "#include <config.h>" in "#ifdef HAVE_CONFIG_H"	1998-04-24 00:43:12 +00:00
curt	712bbc9085	Removed an extra #ifdef __cplusplus, then "}", #endif	1998-04-22 13:19:00 +00:00
curt	7b2370d608	C++ - ified comments. Make file open errors fatal.	1998-04-22 13:18:10 +00:00
curt	98f398c99a	Modified Files: Makefile.am Makefile.in Added Files: interpolater.cxx interpolater.hxx	1998-04-21 19:14:21 +00:00
curt	e5efd5bf69	Prepairing for C++ integration.	1998-04-21 17:03:45 +00:00
curt	9d504a9e19	Added Debug, Math, and zlib libraries.	1998-04-18 03:54:32 +00:00
curt	e96e09d112	Miscellaneous Tweaks.	1998-04-18 03:53:41 +00:00
curt	28a6ec8065	Moved to Lib directory and created a libDebug.	1998-04-18 03:52:03 +00:00
curt	875560b8dc	Initial revision.	1998-04-18 03:48:29 +00:00
curt	fa360360cb	Code reorganizations. Added a Lib/ directory for more general libraries.	1998-04-14 02:43:50 +00:00
curt	e543b5228c	Code reorganizations. Added a Lib/ directory for more general libraries.	1998-04-14 02:23:15 +00:00
curt	63ea6cd15a	Tweaks to Gnu automake/autoconf system.	1998-04-08 23:35:37 +00:00
curt	79a773d25c	Adopted Gnu automake/autoconf system.	1998-04-08 23:28:57 +00:00
curt	dcc537e040	Minor cleanups and reorganizations.	1998-04-06 15:56:23 +00:00
curt	37488d0f7e	Converting to Gnu autoconf system.	1998-04-03 22:10:27 +00:00
curt	aa645019e9	Incorporated code changes contributed by Charlie Hotchkiss <chotchkiss@namg.us.anritsu.com>	1998-02-12 21:59:56 +00:00
curt	6179ec5319	Removed "depend" files from cvs control. Other minor make tweaks.	1998-02-09 22:56:59 +00:00
curt	331f91ba43	Lots of little tweaks to fix various consistency problems discovered by Solaris' CC. Fixed a bug in fg_debug.c with how the fgPrintf() wrapper passed arguments along to the real printf(). Also incorporated HUD changes by Michele America.	1998-02-03 23:20:27 +00:00
curt	a50203dfec	Added MetroWorks patches from Carmen Volpe.	1998-01-31 00:43:18 +00:00
curt	b7eab24f14	Incorporated Paul Bleisch's <bleisch@chromatic.com> new debug message system and commandline/config file processing code.	1998-01-27 00:47:59 +00:00
curt	d824ffd02b	Changed #ifdef FILE_H to #ifdef _FILE_H	1998-01-22 02:59:38 +00:00
curt	238c6f7c88	More misc. tweaks for rpk make merge.	1998-01-19 19:43:07 +00:00
curt	0dd244fb0c	Merged in make system changes from Bob Kuehne <rpk@sgi.com> This should simplify things tremendously.	1998-01-19 19:27:10 +00:00
curt	61a8afa06a	Tons of little changes to clean up the code and to remove fatal errors when building with the c++ compiler.	1998-01-19 18:40:33 +00:00
curt	ed49eadb6a	Minor tweaks and fixes for cygwin32.	1998-01-19 18:35:54 +00:00
curt	ecf19f8af4	Beginning to integrate Tile management subsystem.	1998-01-08 02:22:11 +00:00
curt	9d5eb462c9	Miscellaneous tweaks.	1998-01-07 03:31:27 +00:00
curt	1088c5fa57	Tweaks to help building with MSVC++	1998-01-06 01:20:19 +00:00
curt	ad2bd3db0f	Integrated new event manager with subsystem initializations.	1997-12-30 20:47:48 +00:00
curt	abbcf855c4	Merged in Durk's changes ...	1997-12-30 16:36:51 +00:00
curt	83e648b7d6	Aligned sky with sun so dusk/dawn effects can be correct relative to the sun.	1997-12-22 04:14:33 +00:00
curt	89d049ff73	Initial revision.	1997-12-22 04:13:17 +00:00
curt	ac3a2bce72	Working on scene rendering order and options.	1997-12-19 16:45:00 +00:00
curt	ad20c2d242	Initial revision.	1997-12-16 00:49:09 +00:00
curt	6c9aa9527d	Add xgl wrappers for debugging. Generate terrain normals on the fly.	1997-12-15 23:54:53 +00:00
curt	7ad1e2be73	Working on new scenery subsystem.	1997-10-30 12:38:43 +00:00
curt	604f038cfb	Continuing to try to align stars correctly.	1997-09-22 14:44:21 +00:00
curt	b185b1a4d9	Changed naming scheme of basic shared structures.	1997-08-27 03:30:20 +00:00
curt	89a65000a5	Merged in initial HUD and Joystick code.	1997-08-25 20:27:23 +00:00
curt	9c83903c2a	Initial revision.	1997-07-31 23:13:14 +00:00
curt	68af57b759	Working on redoing internal coordinate systems & scenery transformations.	1997-07-31 22:52:27 +00:00
curt	9c4b4abb50	Moved fg_random routines from Util/ to Math/	1997-07-30 16:12:41 +00:00
curt	233ffb3b10	Moved random routines from Utils/ to Math/	1997-07-30 16:04:08 +00:00
curt	34e2bac4d0	Put comments around the text after an #endif for increased portability.	1997-07-23 21:52:21 +00:00
curt	6d4c38a3c8	Eliminated some harmless compiler warnings.	1997-07-21 21:20:28 +00:00
curt	b6ec5707e8	First stab at a system to generate os2 makefiles automatically.	1997-07-20 02:19:11 +00:00
curt	68d3b7b20c	Added ranlib.	1997-07-12 02:24:46 +00:00
curt	b84b36d885	Initial revision.	1997-07-07 21:02:36 +00:00
curt	f43e375d62	Working on scenery transformations to enable us to fly fluidly over the poles with no discontinuity/distortion in scenery.	1997-07-07 20:59:48 +00:00
curt	ab67fa2c15	renamed mat3 directory to Math so we could add other math related routines.	1997-07-05 20:43:31 +00:00
curt	7aff56c284	Working on Makefile structure.	1997-06-27 21:38:14 +00:00
curt	c13dc3a829	Working on Makefile structure.	1997-06-27 20:03:40 +00:00
curt	baf89c9d63	Restructuring make, adding automatic "make dep" support.	1997-06-26 19:08:38 +00:00
curt	a8b4d21a65	Minor changes to compile with rsxnt/win32.	1997-06-25 15:39:49 +00:00
curt	6c20288ff1	The LaRCsim flight model is starting to look like it is working.	1997-05-30 19:30:16 +00:00
curt	935d4f3bda	The MAT3 routines from SRGP.	1997-05-30 19:25:54 +00:00