Updates for the official 0.3.4 version.

generally are turned on all the time.

Doxyfile

@@ -22,7 +22,7 @@ PROJECT_NAME           = SimGear
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.3.0
+PROJECT_NUMBER         = 0.3.4
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 
@@ -64,14 +64,14 @@ EXTRACT_STATIC         = NO
 # various overviews, but no documentation section is generated. 
 # This option has no effect if EXTRACT_ALL is enabled. 
 
-HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_MEMBERS     = YES
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
 # undocumented classes that are normally visible in the class hierarchy. 
 # If set to NO (the default) these class will be included in the various 
 # overviews. This option has no effect if EXTRACT_ALL is enabled. 
 
-HIDE_UNDOC_CLASSES     = NO
+HIDE_UNDOC_CLASSES     = YES
 
 # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
 # include brief member descriptions after the members that are listed in 
@@ -298,6 +298,7 @@ WARN_LOGFILE           =
 # with spaces. 
 
 INPUT                  = \
+        DoxygenMain.cxx \
 	simgear/bucket \
 	simgear/compiler.h \
 	simgear/constants.h \
@@ -307,13 +308,14 @@ INPUT                  = \
 	simgear/magvar \
 	simgear/math \
 	simgear/misc \
+        simgear/props \
 	simgear/route \
+	simgear/scene \
 	simgear/screen \
 	simgear/serial \
 	simgear/sg_inlines.h \
 	simgear/sg_traits.hxx \
-	simgear/sg_zlib.h \
-	simgear/sky \
+        simgear/sound \
 	simgear/threads \
 	simgear/timing \
 	simgear/xml
@@ -335,7 +337,7 @@ RECURSIVE              = YES
 # excluded from the INPUT source files. This way you can easily exclude a 
 # subdirectory from a directory tree whose root is specified with the INPUT tag. 
 
-EXCLUDE                = simgear/metakit simgear/zlib
+EXCLUDE                = simgear/scene/sky/clouds3d
 
 # If the value of the INPUT tag contains directories, you can use the 
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
@@ -385,7 +387,7 @@ FILTER_SOURCE_FILES    = NO
 # of all compounds will be generated. Enable this if the project 
 # contains a lot of classes, structs, unions or interfaces. 
 
-ALPHABETICAL_INDEX     = NO
+ALPHABETICAL_INDEX     = YES
 
 # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
 # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
@@ -514,7 +516,7 @@ COMPACT_LATEX          = NO
 # by the printer. Possible values are: a4, a4wide, letter, legal and 
 # executive. If left blank a4wide will be used. 
 
-PAPER_TYPE             = a4wide
+PAPER_TYPE             = letter
 
 # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
 # packages that should be included in the LaTeX output. 

DoxygenMain.cxx

@@ -0,0 +1,108 @@
+/* This is a dummy code file that only contains doxygen main page
+   documentation.  It has a .cxx extension so that emacs will happily
+   autoindent correctly. */
+
+/** \mainpage SimGear
+ * Simulation, Visualization, and Game development libraries.
+
+ * \section intro Introduction
+ *
+ * SimGear is a collection of libraries which provide a variety of
+ * functionality useful for building simulations, visualizations, and
+ * even games.  All the SimGear code is designed to be portable across
+ * a wide variety of platforms and compilers.  It has primarily been
+ * developed in support of the FlightGear project, but as development
+ * moves forward, we are generalizing the code to make more of it
+ * useful for other types of applications.
+ *
+ * Some of the functionality provide includes
+ *
+ * - Compiler and platform abstractions for many tricky differences.
+ *   (compiler.h)
+ *
+ * - A whole earth tiling/indexing scheme.  (SGBucket)
+ *
+ * - A console debugging output scheme that tracks severity and
+ *   category that can be completely compiled out for a final build release.
+ *   (logstream.hxx)
+ *
+ * - Code to manage "real" time (SGTime), time zones (SGTimeZone), and
+ *   millesecond time differences (SGTimeStamp).
+ *
+ * - Code to calculate accurate positions of sun, moon, stars, and
+ *   planets for a given time, date, season, earth location, etc.
+ *   (SGEphemeris)
+ *
+ * - Code to render a realistic sky dome, cloud layers, sun, moon,
+ *   stars, and planets all with realistic day/night/sunset/sunrise
+ *   effects.  Includes things like correct moon phase, textured moon,
+ *   sun halo, etc. (SGSky is built on top of SGCloudLayer ...)
+ *
+ * - Simple serial (SGSerial), file (SGFile), socket (SGSocket), and
+ *   UDP socket (SGSocketUDP) I/O abstractions.
+ *
+ * - Code to calculate magnetic variation. (SGMagVar)
+ *
+ * - A variety of classes and functions for interpolation tables
+ *   (SGInterpTable), least squares computation (leastsqs.hxx), 3D
+ *   point/vectors (Point3D), 3D polar math and conversions (polar3d.hxx),
+ *   WGS-84 math and conversions (sg_geodesy.hxx), random number abstraction
+ *   (sg_random.h), STL conglomerates for common list types (sg_types.hxx),
+ *   and other vector and linear algebra routines (vector.hxx)
+ *
+ * - An abstraction to hide platform dependent path naming schemes. (SGPath)
+ *
+ * - A C++ streams wrapper to handle compress input/output streams.
+ *   (sg_gzifstream)
+ *
+ * - An optimized "property manager" which associates ascii property
+ *   names with their corresponding value.  This can be a great way to build
+ *   loose linkages between modules, or build linkages/connections that can
+ *   be determined from config files or at runtime.  (SGPropertyNode)
+ *   Also included is a set of functions to dump the property tree into a
+ *   standard xml file and subsequently read/parse a standard xml file and
+ *   rebuild the associated property tree.  (props_io.hxx)
+ *
+ * - Scene management and drawing routines:
+ *   - material property management
+ *   - object management
+ *   - terrain tile management and paging
+ *   - sky dome rendering (with ephemeral objects)
+ *
+ * - Code to handle screen dumps (screen-dump.hxx) and ultra-hires
+ *   tile rendered screen dumps (tr.h)
+ *
+ * - A sound effects manager.  (SGSoundMgr, SGSimpleSound, SGSound)
+ *
+ * - A threading abstraction.  (SGThread)
+ *
+ * - A simple but highly functional XML parser that interfaces nicely
+ *   with the property manager.  (easyxml.hxx)
+
+ * \section supports Supported Platforms
+ * SimGear has been built on the following platforms:
+ *
+ *   - Linux (x86)
+ *   - Windows (MSVC, Cygwin, Mingwin)
+ *   - SGI (native compilers)
+ *   - Mac OS X
+ *   - FreeBSD
+ 
+ * \section depends Dependencies
+ *
+ * SimGear depends on several other open source packages.  These must
+ * be installed before SimGear can be installed:
+ *
+ *   - glut and opengl
+ *   - plib (http://plib.sf.net)
+ *   - metakit
+ *   - zlib
+ *   - libjpeg (optional)
+ *   - pthread (optional)
+ 
+ * \section license Licensing
+ *
+ * SimGear is licensed under the terms of the LGPL
+
+ */
+

Makefile.am

@@ -1,6 +1,7 @@
 EXTRA_DIST = \
 	acinclude.m4 \
 	autogen.sh \
+	DoxygenMain.cxx
 	README.MSVC \
 	README.metakit \
 	README.zlib \
@@ -10,7 +11,7 @@ EXTRA_DIST = \
 SUBDIRS	= src-libs simgear
 
 dist-hook:
-	(cd $(top_srcdir); $(HOME)/projects/FlightGear-0.7/admin/am2dsp.pl)
+	(cd $(top_srcdir); $(HOME)/projects/FlightGear-0.9/admin/am2dsp.pl)
 
 #
 # Rule to build RPM distribution package

NEWS

@@ -1,3 +1,74 @@
+New in 0.3.4
+* October 22, 2003
+
+* Removed Metakit, FlightGear no longer uses it.
+* Removed all glut dependencies from SimGear.
+* Moved FGEventMgr and FGSubsystemMgr over to SimGear.
+* Some more incremental work on 3D clouds.
+* Added some "fastmath" functions.
+* Some lighting tweaks and fixes (especially for taxiways.)
+* Added support for "blend" and "scale" and "texture" animations.
+* Added support for animating rotations around an arbitrary axis (so the
+  aircraft designer isn't forced to figure out animations as a combination
+  of rotations around X, Y, and X axes.
+* Updates to sky dome modeling and make cloud layers follow the curve
+  of the earth (sort of.)
+* Updates to sky dome, cloud, and sunrise/sunset color and lighting
+  effects to make them more realistic and lifelike.
+* Better support for detecting and using OpenGL extensions at run time.
+* Add support for win32-pthreads in MSVC.NET
+* Various MSVC fixes.
+* Various Solaris fixes.
+* Various cygwin/mingwin fixes.
+* Various Mac OS X fixes.
+* Various Irix fixes.
+
+
+New in 0.3.3
+* June 3, 2003
+
+* Fix a compile problem for cygwin
+* Updated/tweaked doxygen documentation in several areas
+
+
+New in 0.3.2
+* June 2, 2003
+
+* Moved quite a bit of low level model management and "state"
+  management code from FlightGear into SimGear and did a substantial
+  amount of restructuring and dependency clean up in the process.
+  Created a "scene" subdirectory with sub-subdirectories for material
+  management, basic model and model animation management, sky
+  rendering, and low level loaders for the "TerraGear" tile object format.
+* Removed support of the flat shaded and non-textured material
+  property varients.  You can still do these things, but extra states
+  are no longer set up automatically.
+* Removed 3d clouds from the default build ... these need a maintainer
+  or better yet, a complete plib-based rewrite.
+* Moved the FlightGear sound effect manager code over to SimGear.
+* Updated the cloud layer surface to better follow the inverted bowl
+  shape.
+* Much work on cloud/sky coloring, and also much work on
+  sunset/sunrise coloring.
+* Fixed an obscure bug in cloud texture loading which caused each
+  cloud texture to be loaded 5 times.  Ouch!
+* Various class and function renaming to make them better fit into the
+  standard SimGear naming scheme.
+* Added some additional convenience functions to the SGPath class.
+* Upgraded the distributed version of metakit.
+* FreeBSD fixes.
+* Irix fixes (better STL/ISO C++ header support.)
+* Mingwin fixes.
+* Better MacOS support
+* MSVC fixes.
+
+
+New in 0.3.1
+* December 4, 2002
+
+* Fix a major packaging blunder with several missing files.
+
+
 New in 0.3.0
 * December 3, 2002
 

README.metakit

@@ -1,285 +0,0 @@
-For your convenience (and with the author's permission) a copy of the
-MetaKit source is bundled with SimGear in $(top_srcdir)/src-libs/.
-You must have metakit installed before you can build SimGear.
-
-- Most linux distributions have a metakit package.  For linux
-  developers, we recommend ysou install your distributions package
-  rather than building from source.
-
-- For developers on most other platforms, you will have to build
-  metakit from source and install it yourself.  For your convenience a
-  tar ball of the metakit source is included with the simgear source
-  distribution.  Untar the metakit source, and follow the included
-  build and installation instructions.
-
-Once metakit is installed you can return to configuring and building
-Simgear.
-
-=============================================================================
-
-Potentially important build note:
-
-  Later on when you are linking programs with -lmk4 (i.e. FlightGear or one
-  of it's associated programs) if you come across an error similar to the
-  following:
-
-     c++  -Wall -O2 -L/usr/local/lib -o gensimple  gensimple.o libAirports.a
-          -lsgdebug -lsgmisc -lmk4 -lz -lm 
-     /usr/local/lib/libmk4.a(view.o)(.text+0x1c8):view.cpp: multiple definition
-          of `c4_View::~c4_View(void)'
-    libAirports.a(simple.o)(.text$_$_7c4_View+0x0):simple.cxx: first defined
-          here
-    collect2: ld returned 1 exit status
-    make[2]: *** [gensimple] Error 1
-    make[2]: Leaving directory `/home/curt/FlightGear-0.7.7/src/Airports'
-    make[1]: *** [all-recursive] Error 1
-    make[1]: Leaving directory `/home/curt/FlightGear-0.7.7/src'
-    make: *** [all-recursive] Error 1
-
-  Then you need to come back and rebuild Metakit with the -DNDEBUG flag.
-  For unix/cygwin systems, modify the unix/Makefile file and add -DNDEBUG
-  to the CFLAGS line.
-
-Now we return you to the official metakit readme ... :-)
-
-
-The MetaKit Library 2.01                                            March 2000
-==============================================================================
-
-
-WHAT IT IS - MetaKit is an embeddable database which runs on Unix, Windows,
-    Macintosh, and other platforms.  It lets you build applications which
-    store their data efficiently, in a portable way, and which will not need a
-    complex runtime installation.  In terms of the data model, MetaKit takes
-    the middle ground between RDBMS, OODBMS, and flat-file databases - yet it
-    is quite different from each of them.
-
-WHAT IT ISN'T - MetaKit is not: 1) multi-user/-threading, 2) scalable to
-    gigabytes, 3) proprietary software, 4) full of bugs, 5) just a toy.
-
-TECHNOLOGY - Everything is stored variable-sized yet with efficient positional
-    row access.  Changing an existing datafile structure is as simple as re-
-    opening it with that new structure.  All changes are transacted.  You can
-    mix and match software written in C++, Python, and Tcl.  Things can't get
-    much more flexible...
-
-CORE - The Metakit core library is written in C++.  It has a code footprint of
-    just over 100 Kb on Windows.  It can be used as DLL, or linked statically.
-    Debug builds include extensive assertion checks to catch problems early.
-
-PYTHON - The binding for Python is called "Mk4py".  It uses SCXX by Gordon
-    McMillan as C++ glue interface.  The source is in directory "python/".
-
-TCL/TK - The MK extension for Tcl is called "Mk4tcl".  It is being used in a
-    number of commercial projects, for in-house use as well as in commercially
-    distributed products.  The source is in directory "tcl/".
-
-LICENSE AND SUPPORT - MetaKit 2.01 is distributed as open source software (the
-    X/MIT-style license is at the end of this document).  Commercial support
-    is available through an Enterprise License, see the URL mentioned below.
-
-DOCUMENTATION - All documentation uses HTML.  The main page is "MetaKit.html",
-    which leads to the rest of the documentation in the "doc/" directory.
-
-WEBSITE URLS - The main pages on the world wide web, for news and downloads:
-    Homepage:       http://www.equi4.com/metakit/
-    Python news:    http://www.equi4.com/metakit/python.html
-    Tcl/Tk news:    http://www.equi4.com/metakit/tcl.html
-    License info:   http://www.equi4.com/metakit/license.html
-    Contact info:   http://www.equi4.com/contact.html
-
-
-INSTALLATION
-============
-
-Starting with this release, all platform builds and language bindings are now
-designed to work from a single common "builds/" directory.  It turns out to
-be impossible to keep build side-effects limited to *just* this directory
-(CodeWarrior can't be told where to place its temp data, and Visual C++ still
-alters a few files next to the project ".dsw" file, to name two offenders).
-
-UNIX
-
-    It is no longer advised to build the Unix code in the "unix/" directory.
-    Instead, you should perform the following steps:
-        % cd builds
-        % ../unix/configure
-        % make
-        % make test
-    And optionally (this only installs the core lib, not script extensions):
-        % make install
-
-    By switching to the "builds/" directory, you will keep the distribution
-    directory tree 100% unaltered.  All changes are made in this subdir, and
-    all final build results are left behind in this same subdir.
-
-    Nastiness: if you build Mk4tcl, please do a "make Mk4tcl.so" as well.
-    And if you intend to create the Python extension, do a "make Mk4py.so".
-    The "libmk4tcl.so.0.0.0" and "libMk4py.so.0.0.0" targets are bogus ones.
-
-    You will probably have to make changes in the makefile to locate the
-    proper includes and libs for Python (Tcl has been fixed, see "--with-tcl).
-    You probably only need to adjust "CXX_SWITCHES_PY" to find the headers.
-
-    To build with STL containers and strings, you can do the following:
-        make CXXFLAGS='-Dq4_STD' test   # add -O3 etc, as needed
-    This passes the test suite on Linux RedHat 5.2 with gcc 2.95-2.
-
-    See below for some platform-specific build notes.
-
-WINDOWS
-
-    There is a "win/" directory which contains subdirectories for a number of
-    compiler systems.  MetaKit has been built with many different compilers
-    in the past (Microsoft, Borland, Watcom, Symantec, Metrowerks, Optima),
-    but to preserve my sanity (there are 12 configurations for MSVC6 alone!),
-    I am limiting myself to MSVC6, MWCW5, Borland C++ Builder 4, and Cygwin.
-
-    The MS Visual C++ 6.0 project is "win/msvc60/mksrc.dsw", with subprojects
-    for the C++ demo (mkdemo), building dll's (mkdll), static libs (mklib),
-    regression tests (mktest), as well as Tcl (mktcl) and Python (mkpython).
-    It has been set up to place all intermediate files and final results in
-    the "builds/" subdirectory, even though you'll launch it from "win/".
-
-    To build with STL containers and strings under MSVC, define "q4_STD".
-    To build with MFC containers and strings under MSVC, define "q4_MFC".
-
-    The Metrowerks Codewarrior project is in the "mac/" directory, and can be
-    used to build both Mac and Windows versions (on either Mac *or* Windows).
-    The core libraries are built with "mac/cw5.mcp", demos / tests are built
-    with "cw5apps.mcp", Tcl is "cw5tcl.mcp", and Python is "cw5python.mcp".
-
-    The Borland C++ Builder projects have not yet been incorporated in this
-    release, but the "KitViewer" application is an example of how to use BCB.
-
-    The Cygwin build (B20.1 / gcc 2.95.2) is different, because it uses the
-    unix autoconf system, and must be launched as described above for UNIX.
-    I have upgraded to the latest development of libtool to be able to build
-    DLL's with Cygwin.  You can build the "-mno-cygwin" version by editing
-    the Makefile by hand and adding that option to CXXFLAGS.
-
-    Rob Bloodgood adds that the following GCC options are for maximum code
-    efficiency on x86 hardware: "-O2 -m486 -malign-loops=2 -malign-jumps=2".
-    I have not yet tried this myself, but am passing on the tip.
-
-MACINTOSH
-
-    The Mac version requires Metrowerks CodeWarrior 5.  See the info above
-    in the Windows section (MWCW is multi-platform).  The projects are all
-    located in the "mac/" folder, which is also where MWCW will place its own
-    "... Data" folders with intermediate results.  As with all other setups,
-    final results are made to end up in the "builds/" directory.
-
-    Static 68K builds appear to work fine, the 68K CFM variants will need
-    some more work (I couldn't get the libraries to export their symbols).
-
-
-PLATFORM-SPECIFIC NOTES
-=======================
-
-* Linux RH 5.2 / gcc 2.95.2
-
-    Builds with gcc 2.95.2 work out of the box.  The Tcl extension ends up as
-    ".libs/libmk4tcl.so.0.0.0" (to please libtool), and should be renamed to
-    "Mk4tcl.so".  Similarly, ".libs/libMk4py.so.0.0.0" is in fact the Python
-    extension, and *must* be renamed to "Mk4py.so" to call it from Python.
-
-    The core MK libs end up as ".libs/libmk4.a" and ".libs/libmk4.so.0.0.0".
-
-* Solaris 2.6 / gcc 2.8.1
-
-    The Solaris builds are nasty for several reasons:
-
-    - I do not own such a machine, and often have to make arrangements
-      (or fight limited space on one of the machines I can telnet to).
-    - The gcc 2.8.1 optimizer appears to be buggy, I have had to turn off
-      the default "-O3" flag to prevent compiler crashes (several files).
-      This problems appears to be resolved with gcc 2.95.
-    - Locking on Solaris (especially w.r.t NFS) remains a mystery to me.
-      The Tcl and Python extensions both use locking (the core not yet).
-      See tcl/Mk4tcl.cpp around line 520, and python/PyStorage.cpp around
-      line 80 for details.  It's all pretty messy, and not 100% correct.
-
-    Despite this, I'm doing my best to resolve these issues.  Having a solid
-    build of the core *and* of Tcl / Python extensions is quite important.
-
-* Other Unix systems
-
-    No further notes, though many systems will build fine out of the box.
-
-* Windows
-
-    MSVC 6 builds MK as static lib and as DLL (universal config, I have not
-    yet created build versions with MFC or STL, mainly because MK can now be
-    used in all contexts regardless of how it was built).  The Python and Tcl
-    extensions build as dynamic extensions (a static build is easy to add).
-
-    MWCW 5 builds MK as static lib and as DLL (interestingly enough, the DLL
-    is slightly smaller than MSVC 6 - 102 vs 108 Kb - when their runtimes are
-    linked in dynamically as well).  I have not added Win builds for Tcl or
-    Python, since MSVC 6 has those already.
-
-    Cygwin B20.1, with gcc 2.95.2 ugrade, also builds MK as static lib and as
-    DLL.  Both "pure" Cygwin (i.e. requiring cygwin1.dll) and mingw32 (using
-    the -mno-cygwin flag) build, but there are some hairy include issues when
-    it comes to choosing the right locking model for Tcl and Python.  These
-    issues have not been resolved fully.
-
-* Macintosh
-
-    MWCW 5 builds PPC shared libs, PPC static libs, and 68K static libraries.
-
-    Building 68K CFM libraries leads to a "MetaKit 68K.shlb" which comes out
-    of the linker without errors, but the result does not seem to have any
-    export symbols defined (despite the fact that the library is over 200 K).
-    Because of that, I've been unable to build apps or Mk4tcl/Mk4py so far.
-
-    The other three configurations build, but for some reason MK's regression
-    test stops at L03 (everything up to that point looks ok, i.e. over 90%).
-
-    The Mk4tcl PPC extension appears to work (quick manual test), and so does
-    the Python extension, "Mk4py.PPC.slb".  I have not yet given these two
-    a serious workout, hoping to have a basic test harness in place soon.
-
-* VMS, BeOS, ...
-
-    No news yet, please report your findings with any other platform builds.
-
-
-WHAT'S MISSING HERE
-===================
-
-    - a section on basic concepts (or maybe it doesn't belong here?)
-    - a section on getting started (C++, Python, Tcl all differ - point to
-      the respective intro pages)
-    - maybe a small sample for each of C++ / Tcl / Python, to give an idea
-    - mention TclKit, scripted docs (WiKit/Tequila?), VFS?
-    - I forgot... please tell me :)
-
-
-LICENSE AND COPYRIGHT STATEMENT
-===============================
-
-Copyright (c) 1996-2000 Jean-Claude Wippler
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-
-==============================================================================
--- Jean-Claude Wippler <jcw@equi4.com>

configure.ac

@@ -1,16 +1,16 @@
-dnl Process this file with aclocal ; automake -a ; autoconf to produce a 
-dnl working configure script.
+dnl Process this file with autoget.sh to produce a working configure
+dnl script.
 dnl
 dnl $Id$
 
 AC_INIT
 AC_CONFIG_SRCDIR([simgear/bucket/newbucket.cxx])
 
-# Require at least automake 2.52
+dnl Require at least automake 2.52
 AC_PREREQ(2.52)
 
 dnl Initialize the automake stuff
-AM_INIT_AUTOMAKE(SimGear, 0.3.0)
+AM_INIT_AUTOMAKE(SimGear, 0.3.4)
 
 dnl Specify KAI C++ compiler and flags.
 dnl Borrowed with slight modification from blitz distribution.
@@ -38,20 +38,28 @@ AC_PROG_RANLIB
 AC_PROG_INSTALL
 AC_PROG_LN_S
 
+dnl set the $host variable based on local machine/os
+AC_CANONICAL_HOST
 
-# Used on the Irix platform
-AR="ar"
-ARFLAGS="cru"
-OS=`uname -s`
-if test "$OS" = "IRIX" -o "$OS" = "IRIX64"; then
-    if test "$CXX" = "CC"; then
-        AR="CC -ar"
+dnl Used on the Irix platform
+case "${host}" in
+*-*-irix*)
+    if test "x$CXX" = "xCC" -o "x$CXX" = "xccache CC"; then
+        AR="$CXX -ar"
         ARFLAGS="-o"
+        CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility"
+        compatibility_DIR="compatibility"
     fi
-fi
+    ;;
+*)
+    AR="ar"
+    ARFLAGS="cru"
+    compatibility_DIR=
+    ;;
+esac
 AC_SUBST(AR)
 AC_SUBST(ARFLAGS)
-
+AC_SUBST(compatibility_DIR)
 
 if echo $includedir | egrep "simgear$" > /dev/null; then
     echo "includedir is" $includedir "libdir is" $libdir
@@ -60,8 +68,7 @@ else
     echo "includedir changed to" $includedir "libdir is" $libdir
 fi
          
-# set logging default value
-# with_logging=yes
+dnl set logging; default value of with_logging=yes
 AC_ARG_WITH(logging, [  --with-logging          Include logging output (default)])
 if test "x$with_logging" = "xno" ; then
     AC_DEFINE([FG_NDEBUG], 1, [Define for no logging output])
@@ -90,38 +97,26 @@ fi
 AM_CONDITIONAL(ENABLE_JPEG_SERVER, test "x$with_jpeg_factory" = "xyes")
 
 
-dnl Check for MS Windows environment
-AC_CHECK_HEADER(windows.h)
+dnl Determine an extra directories to add to include/lib search paths
+case "${host}" in
+*-apple-darwin* | *-*-mingw32*)
+    echo no EXTRA_DIRS for $host
+    ;;
 
-AC_EGREP_CPP(yes,
-[#ifdef __MINGW32__
- yes
- #endif
-],is_mingw=yes, is_mingw=no)
-
-echo "IS_MINGW = $is_mingw"
-AM_CONDITIONAL(IS_MINGW, test "x$is_mingw" = "xyes")
-
-AC_EGREP_CPP(yes,
-[#ifdef __CYGWIN__
- yes
- #endif
-],is_cygwin=yes, is_cygwin=no)
-
-echo "IS_CYGWIN = $is_cygwin"
-AM_CONDITIONAL(IS_CYGWIN, test "x$is_cygwin" = "xyes")
-
-if test "x$HOSTTYPE" != "xmacintosh" -a "x$is_mingw" != "xyes"; then
-    dnl extra library and include directories
-    EXTRA_DIRS="/usr/X11R6"
-
-    if test -d /opt/X11R6 ; then
-        EXTRA_DIRS="$EXTRA_DIRS /opt/X11R6"
+*)
+    if test -d /usr/X11R6 ; then
+        EXTRA_DIR1="/usr/X11R6"
     fi
-fi
+    if test -d /opt/X11R6 ; then
+        EXTRA_DIR2="/opt/X11R6"
+    fi
+    EXTRA_DIRS="$EXTRA_DIR1 $EXTRA_DIR2"
+    ;;
 
+esac
 wi_EXTRA_DIRS(no, ${EXTRA_DIRS})
 
+
 dnl Using AM_CONDITIONAL is a step out of the protected little 
 dnl automake fold so it is potentially dangerous.  But, we are
 dnl beginning to run into cases where the standard checks are not
@@ -129,67 +124,113 @@ dnl enough.  AM_CONDITIONALS are then referenced to conditionally
 dnl build a Makefile.in from a Makefile.am which lets us define custom
 dnl includes, compile alternative source files, etc.
 
-dnl X11 might be installed on Mac OS X, don't want to use it if it is.
-if test "x$HOSTTYPE" != "xmacintosh" ; then
-    dnl Check for X11 (fancy)
+dnl X11 might be installed on Mac OS X or cygwin/mingwin, we don't want
+dnl to use it if it is.
+case "${host}" in
+*-apple-darwin* | *-*-cygwin* | *-*-mingw32*)
+    echo no fancy X11 check
+    ;;
+
+*)
     AC_PATH_XTRA
-fi
+    ;;
+
+esac
 
 dnl Checks for libraries.
 
-null_LIBS="$LIBS"
-
-AC_CHECK_LIB(m, cos)
-
-base_LIBS="$LIBS"
-
 dnl Thread related checks
-AC_CHECK_LIB(pthread, pthread_exit)
 AC_CHECK_HEADER(pthread.h)
+AC_CHECK_LIB(pthread, pthread_exit)
 if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes"; then
     CXXFLAGS="$CXXFLAGS -D_REENTRANT"
     CFLAGS="$CFLAGS -D_REENTRANT"
 fi
-AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes")
-
-AC_CHECK_LIB(socket, socket)
-
-dnl X11 might be installed, but we don't want to use it for OSX -dw-
-if test "x$HOSTTYPE" != "xmacintosh" ; then
-    AC_CHECK_LIB(X11, XCreateWindow)
-    AC_CHECK_LIB(Xext, XShmCreateImage)
-    AC_CHECK_LIB(Xi, XGetExtensionVersion)
-    AC_CHECK_LIB(ICE, IceOpenConnection)
-    AC_CHECK_LIB(SM, SmcOpenConnection)
-    AC_CHECK_LIB(Xt, XtMalloc)
-    AC_CHECK_LIB(Xmu, XmuLookupStandardColormap)
+if test "x$ac_cv_lib_pthread_pthread_exit" != "xyes" -a "x$ac_cv_header_pthread_h" = "xyes"; then
+    dnl FreeBSD: System has pthread.h, but -lpthread library check
+    dnl fails.  See if we need -pthread instead of -lpthread and look
+    dnl for the functions in libc_r.
+    save_CXXFLAGS="$CXXFLAGS"
+    save_CFLAGS="$CFLAGS"
+    CXXFLAGS="-pthread $CXXFLAGS"
+    CFLAGS="-pthread $FLAGS"
+    save_LIBS=$LIBS
+    AC_CHECK_LIB(c_r, pthread_exit)
+    if test "x$ac_cv_lib_c_r_pthread_exit" != "xyes"; then
+        CXXFLAGS=$save_CXXFLAGS
+        CFLAGS=$save_CFLAGS
+    else
+        dnl This is cheating a bit. pthread_exit comes with using -pthread, not
+-lpthread
+        ac_cv_lib_pthread_pthread_exit="yes"
+    fi
+    LIBS=$save_LIBS
 fi
 
+AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes")
+
+thread_LIBS="$LIBS"
+LIBS=""
+
+dnl search for network related libraries
+AC_SEARCH_LIBS(inet_addr, xnet)
+AC_SEARCH_LIBS(socket, socket)
+
+network_LIBS="$LIBS"
+LIBS=""
+
+dnl check for some default libraries
+AC_SEARCH_LIBS(cos, m)
+
+base_LIBS="$LIBS"
+
 dnl check for OpenGL related libraries
+case "${host}" in
+*-*-cygwin* | *-*-mingw32*)
+    dnl CygWin under Windoze.
 
-AM_CONDITIONAL(EXTGL_NEEDED, test "x$ac_cv_header_windows_h" = "xyes")
+    echo Win32 specific hacks...
+    AC_DEFINE([WIN32], 1, [Define for Win32 platforms])
+    AC_DEFINE([NOMINMAX], 1, [Define for Win32 platforms])
 
-if test "x$HOSTTYPE" = "xmacintosh" ; then
-    dnl Macintosh OSX
-    LIBS="$LIBS -framework OpenGL -framework GLUT"
-elif test "x$ac_cv_header_windows_h" != "xyes" ; then
-    dnl Reasonable stuff for X-Windows based machines
+    LIBS="$LIBS -lglu32 -lopengl32"
+    LIBS="$LIBS -luser32 -lgdi32 -lwinmm"
 
-    AC_CHECK_LIB(GLcore, glNewList)
-    if test "x$ac_cv_lib_GLcore_glNewList" = "xno" ; then
-	dnl if no GLcore, check for GL
-	AC_CHECK_LIB(GL, glNewList)
-	if test "x$ac_cv_lib_GL_glNewList" = "xno" ; then
-	    dnl if no GL, check for MesaGL
-	    AC_CHECK_LIB(MesaGL, glNewList)
-	fi
-    else
+    dnl add -lwsock32 for mingwin
+    case "${host}" in
+    *-*-mingw32*)
+        base_LIBS="$base_LIBS -lws2_32"
+        ;;
+    esac
+
+    echo "Will link apps with $LIBS"
+    ;;
+
+*-apple-darwin*)
+    dnl Mac OS X
+
+    LIBS="$LIBS -framework OpenGL -framework Carbon -lobjc"
+    ;;
+
+*)
+    dnl X-Windows based machines
+
+    AC_SEARCH_LIBS(XCreateWindow, X11)
+    AC_SEARCH_LIBS(XShmCreateImage, Xext)
+    AC_SEARCH_LIBS(XGetExtensionVersion, Xi)
+    AC_SEARCH_LIBS(IceOpenConnection, ICE)
+    AC_SEARCH_LIBS(SmcOpenConnection, SM)
+    AC_SEARCH_LIBS(XtMalloc, Xt)
+    AC_SEARCH_LIBS(XmuLookupStandardColormap, Xmu)
+    
+    AC_SEARCH_LIBS(glNewList, [ GL GLcore MesaGL ])
+    if test "x$ac_cv_search_glNewList" = "x-lGLcore"; then
 	dnl if GLcore found, then also check for GL
-	AC_CHECK_LIB(GL, glXCreateContext)
+        AC_SEARCH_LIBS(glXCreateContext, GL)
     fi
 
     dnl if using mesa, check for xmesa.h
-    if test "x$ac_cv_lib_MesaGL_glNewList" = "xyes" ; then
+    if test "x$ac_cv_search_glNewList" = "x-lMesaGL"; then
 	AC_CHECK_HEADER(GL/fxmesa.h)
 	if test "x$ac_cv_header_GL_fxmesa_h" = "xyes"; then
 	    AC_DEFINE([XMESA], 1, [Define for fxmesa])
@@ -197,76 +238,22 @@ elif test "x$ac_cv_header_windows_h" != "xyes" ; then
         fi
     fi
 
-    AC_CHECK_LIB(GLU, gluLookAt)
-    if test "x$ac_cv_lib_GLU_gluLookAt" = "xno" ; then
-	dnl if no GLU, check for MesaGLU
-	AC_CHECK_LIB(MesaGLU, gluLookAt)
-    fi
+    AC_SEARCH_LIBS(gluLookAt, [ GLU MesaGLU ])
+    ;;
 
-    dnl check for glut
-    AC_CHECK_LIB(glut, glutGetModifiers)
-
-    dnl test for glutGameModeString, but avoid adding glut a second time into
-    dnl the list of libraries
-    save_LIBS="$LIBS"
-    AC_CHECK_LIB(glut, glutGameModeString)
-    LIBS="$save_LIBS"
-else
-    dnl Win32 libs
-
-    echo Win32 specific hacks...
-    AC_DEFINE([WIN32], 1, [Define for Win32 platforms])
-    AC_DEFINE([NOMINMAX], 1, [Define for Win32 platforms])
-
-    dnl just define these to true and hope for the best
-    ac_cv_lib_glut_glutGetModifiers="yes"
-    ac_cv_lib_glut_glutGameModeString="yes"
-
-    if test "x$with_sgi_opengl" = "xyes" ; then
-        echo "Building with glut.dll, glu.dll, and opengl.dll"
-	WIN32_GLUT=glut
-	WIN32_GLU=glu
-	WIN32_OPENGL=opengl
-    else 
-	echo "Building with glut32.dll, glu32.dll, and opengl32.dll"
-	WIN32_GLUT=glut32
-	WIN32_GLU=glu32
-	WIN32_OPENGL=opengl32
-    fi
-
-    LIBS="$LIBS -l${WIN32_GLUT} -l${WIN32_GLU} -l${WIN32_OPENGL}"
-    LIBS="$LIBS -luser32 -lgdi32"
-    if test "x$is_mingw" = "xyes" ; then
-        EXTRA_DIRS="${EXTRA_DIRS}"
-    fi
-    echo "Will link apps with $LIBS"
-fi
-
-if test "x$ac_cv_lib_glut_glutGetModifiers" = "xno"; then
-    echo 
-    echo "Unable to find the necessary OpenGL or GLUT libraries."
-    echo "See config.log for automated test details and results ..."
-    exit 1
-fi
-
-if test "x$ac_cv_lib_glut_glutGameModeString" = "xno"; then
-    echo
-    echo "Your version of glut doesn't support game mode."
-    echo "You need to install the latest version of glut.  If your"
-    echo "distribution doesn't provide a newer version, you can get the source"
-    echo "code from:"
-    echo
-    echo "    http://reality.sgi.com/opengl/glut3/glut3.html"
-    exit 1
-fi
+esac
 
 opengl_LIBS="$LIBS"
 LIBS="$base_LIBS"
 
 AC_SUBST(base_LIBS)
 AC_SUBST(opengl_LIBS)
+AC_SUBST(thread_LIBS)
+AC_SUBST(network_LIBS)
 
-AM_CONDITIONAL(HAVE_XWINDOWS, test "x$ac_cv_lib_X11_XCreateWindow" = "xyes" )
+dnl Check for MS Windows environment
+AC_CHECK_HEADER(windows.h)
+AM_CONDITIONAL(EXTGL_NEEDED, test "x$ac_cv_header_windows_h" = "xyes")
 
 # The following are C++ items that need to be tested for with the c++
 # compiler
@@ -309,33 +296,31 @@ int main() {
   AC_MSG_RESULT(yes)
 )
 
-dnl Check for system installed metakit
-AC_CHECK_HEADER(mk4.h)
-if test "x$ac_cv_header_mk4_h" != "xyes"; then
-    echo 
-    echo "Metakit not found, you will need to install this first."
-    echo "Please read the README.metakit for more information."
-    exit
-fi
+LIBS="$saved_LIBS"
 
 AC_LANG_POP
 
-dnl Specify if we want logging (testing build) or not (release build)
-
 dnl Check for system installed zlib
 AC_CHECK_HEADER(zlib.h)
 if test "x$ac_cv_header_zlib_h" != "xyes"; then
-    echo 
-    echo "zlib not found, you will need to install this first."
-    echo "Please read the README.zlib for more information."
-    exit
+    echo
+    echo "zlib library not found."
+    echo
+    echo "If your OS does not provide an installable package for zlib"
+    echo "you will have to compile and install it first yourself.  A copy"
+    echo "of zlib-1.1.4.tar.gz is included with SimGear.  You will"
+    echo "have to untar this source code, and follow its included instructions"
+    echo "to compile and install on your system."
+    echo
+    echo "configure aborted."
+    echo
 fi
 
 dnl Checks for header files.
 AC_HEADER_STDC
 AC_CHECK_HEADERS( \
 	fcntl.h getopt.h malloc.h memory.h stdint.h stdlib.h sys/param.h \
-	sys/stat.h sys/time.h sys/timeb.h unistd.h windows.h winbase.h values.h )
+	sys/stat.h sys/time.h sys/timeb.h unistd.h values.h )
 
 if test "x$ac_cv_header_stdint_h" = "xyes"; then
     AC_DEFINE([HAVE_STDINT_H], 1, [Define if stdint.h exists])
@@ -350,7 +335,8 @@ AC_STRUCT_TM
 dnl Checks for library functions.
 AC_TYPE_SIGNAL
 AC_FUNC_VPRINTF
-AC_CHECK_FUNCS( ftime gettimeofday timegm memcpy bcopy mktime strstr rand \
+AC_CHECK_FUNCS( \
+        ftime gettimeofday timegm memcpy bcopy mktime strstr rand \
 	random drand48 setitimer getitimer signal GetLocalTime rint getrusage )
 
 AM_CONFIG_HEADER(simgear/simgear_config.h)
@@ -361,6 +347,7 @@ AC_CONFIG_FILES([ \
 	src-libs/Makefile \
 	simgear/Makefile \
 	simgear/version.h \
+	simgear/compatibility/Makefile \
 	simgear/bucket/Makefile \
 	simgear/debug/Makefile \
 	simgear/ephemeris/Makefile \
@@ -369,11 +356,18 @@ AC_CONFIG_FILES([ \
 	simgear/math/Makefile \
 	simgear/metar/Makefile \
 	simgear/misc/Makefile \
+	simgear/props/Makefile \
 	simgear/route/Makefile \
+	simgear/scene/Makefile \
+	simgear/scene/material/Makefile \
+	simgear/scene/model/Makefile \
+	simgear/scene/sky/Makefile \
+	simgear/scene/sky/clouds3d/Makefile \
+	simgear/scene/tgdb/Makefile \
 	simgear/screen/Makefile \
 	simgear/serial/Makefile \
-	simgear/sky/Makefile \
-	simgear/sky/clouds3d/Makefile \
+	simgear/sound/Makefile \
+	simgear/structure/Makefile \
 	simgear/threads/Makefile \
 	simgear/timing/Makefile \
 	simgear/xgl/Makefile \
@@ -394,7 +388,7 @@ else
     echo "Debug messages: yes"
 fi
 
-echo -n "Automake version: ($AUTO_MAKE_VERSION) "
+echo -n "Automake version: "
 automake --version | head -1
 
 if test "x$with_jpeg_factory" = "xyes"; then
@@ -408,3 +402,4 @@ if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h
 else
    echo "Threads: no threads (pthread lib not found.)"
 fi
+

simgear/Makefile.am

@@ -10,24 +10,28 @@ METAR_DIRS = metar
 EXTRA_DIST = simgear_config.h.vc5 version.h.in
 
 include_HEADERS = \
-	compiler.h constants.h sg_inlines.h sg_traits.hxx sg_zlib.h version.h
+	compiler.h constants.h sg_inlines.h sg_traits.hxx version.h
 
 SUBDIRS = \
+	$(compatibility_DIR) \
 	xml \
 	debug \
 	misc \
+	structure \
 	bucket \
 	ephemeris \
 	io \
 	magvar \
 	math \
 	$(METAR_DIRS) \
+	props \
 	route \
+	scene \
 	screen \
 	serial \
-	sky \
+	sound \
 	$(SGTHREAD_DIR) \
 	timing \
 	xgl
 
-DIST_SUBDIRS = $(SUBDIRS)
+DIST_SUBDIRS = $(SUBDIRS) compatibility metar threads

simgear/bucket/newbucket.hxx

@@ -54,10 +54,7 @@ SG_USING_STD(fabs);
 #include STL_STRING
 
 SG_USING_STD(string);
-
-#if ! defined( SG_HAVE_NATIVE_SGI_COMPILERS )
 SG_USING_STD(ostream);
-#endif
 
 
 /**

simgear/compatibility/.cvsignore

@@ -0,0 +1,2 @@
+Makefile
+Makefile.in

simgear/compatibility/IRIX

@@ -0,0 +1,43 @@
+
+#ifndef __SGI_HXX
+#define __SGI_HXX
+
+#include <string>
+
+inline bool
+operator!=( const std::string& lhs, const char* rhs)
+{
+    return lhs.compare( rhs ) != 0;
+}
+
+inline bool
+operator!=( const char* lhs, const std::string& rhs)
+{
+    return rhs.compare( lhs ) != 0;
+}
+
+inline bool
+operator==( const std::string& lhs, const char* rhs)
+{
+    return lhs.compare( rhs ) == 0;
+}
+
+inline bool
+operator==( const char* lhs, const std::string& rhs)
+{
+    return rhs.compare( lhs ) == 0;
+}
+
+inline std::string
+operator+(const std::string& lhs, const char* rhs)
+{
+    return lhs + std::string(rhs);
+}
+
+inline std::string
+operator+(const char* lhs, const std::string& rhs)
+{
+    return std::string(lhs) + rhs;
+}
+
+#endif // !__SGI_HXX

simgear/compatibility/Makefile.am

@@ -0,0 +1,33 @@
+includedir = @includedir@/compatibility
+
+EXTRA_DIST = README
+
+include_HEADERS	= \
+	cfloat \
+	csetjmp \
+	cstdio \
+	cwchar \
+	iostream \
+	strstream \
+	sstream \
+	cassert \
+	climits \
+	csignal \
+	cstdlib \
+	cwctype \
+	istream \
+	cctype \
+	clocale \
+	cstdarg \
+	cstring \
+	fstream \
+	iterator \
+	cerrno \
+	cmath \
+	cstddef \
+	ctime \
+	iomanip \
+	new \
+	streambuf \
+	\
+	IRIX

simgear/compatibility/README

@@ -0,0 +1,9 @@
+
+The following header files where taken from the boost clib package
+(http://www.boost.org):
+
+cassert climits  csignal   cstdlib   cwctype
+cctype  clocale  cstdarg   cstring
+cerrno  cmath    cstddef   ctime
+cfloat  csetjmp  cstdio    cwchar
+

simgear/compatibility/cassert

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CASSERT_HEADER
+#define __CASSERT_HEADER
+
+#include <assert.h>
+
+#endif // CASSERT_HEADER

simgear/compatibility/cctype

@@ -0,0 +1,26 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CCTYPE_HEADER
+#define __CCTYPE_HEADER
+
+#include <ctype.h>
+
+namespace std {
+  using ::isalnum;
+  using ::isdigit;
+  using ::isprint;
+  using ::isupper;
+  using ::tolower;
+  using ::isalpha;
+  using ::isgraph;
+  using ::ispunct;
+  using ::isxdigit;
+  using ::toupper;
+  using ::iscntrl;
+  using ::islower;
+  using ::isspace;
+}
+
+#endif // CCTYPE_HEADER

simgear/compatibility/cerrno

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CERRNO_HEADER
+#define __CERRNO_HEADER
+
+#include <errno.h>
+
+#endif // CERRNO_HEADER

simgear/compatibility/cfloat

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CFLOAT_HEADER
+#define __CFLOAT_HEADER
+
+#include <float.h>
+
+#endif // CFLOAT_HEADER

simgear/compatibility/climits

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CLIMITS_HEADER
+#define __CLIMITS_HEADER
+
+#include <limits.h>
+
+#endif // CLIMITS_HEADER

simgear/compatibility/clocale

@@ -0,0 +1,16 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CLOCALE_HEADER
+#define __CLOCALE_HEADER
+
+#include <locale.h>
+
+namespace std {
+  using ::lconv;
+  using ::localeconv;
+  using ::setlocale;
+}
+
+#endif // CLOCALE_HEADER

simgear/compatibility/cmath

@@ -0,0 +1,35 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CMATH_HEADER
+#define __CMATH_HEADER
+
+#include <math.h>
+
+namespace std {
+  using ::acos;
+  using ::cos;
+  using ::fmod;
+  using ::modf;
+  using ::tan;
+  using ::asin;
+  using ::cosh;
+  using ::frexp;
+  using ::pow;
+  using ::tanh;
+  using ::atan;
+  using ::exp;
+  using ::ldexp;
+  using ::sin;
+  using ::atan2;
+  using ::fabs;
+  using ::log;
+  using ::sinh;
+  using ::ceil;
+  using ::floor;
+  using ::log10;
+  using ::sqrt;
+}
+
+#endif // CMATH_HEADER

simgear/compatibility/csetjmp

@@ -0,0 +1,15 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSETJMP_HEADER
+#define __CSETJMP_HEADER
+
+#include <setjmp.h>
+
+namespace std {
+  using ::jmp_buf;
+  using ::longjmp;
+}
+
+#endif // CSETJMP_HEADER

simgear/compatibility/csignal

@@ -0,0 +1,16 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSIGNAL_HEADER
+#define __CSIGNAL_HEADER
+
+#include <signal.h>
+
+namespace std {
+  using ::sig_atomic_t;
+  using ::raise;
+  using ::signal;
+}
+
+#endif // CSIGNAL_HEADER

simgear/compatibility/cstdarg

@@ -0,0 +1,14 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDARG_HEADER
+#define __CSTDARG_HEADER
+
+#include <stdarg.h>
+
+namespace std {
+  using ::va_list;
+}
+
+#endif // CSTDARG_HEADER

simgear/compatibility/cstddef

@@ -0,0 +1,15 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDDEF_HEADER
+#define __CSTDDEF_HEADER
+
+#include <stddef.h>
+
+namespace std {
+  using ::ptrdiff_t;
+  using ::size_t;
+}
+
+#endif // CSTDDEF_HEADER

simgear/compatibility/cstdio

@@ -0,0 +1,57 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDIO_HEADER
+#define __CSTDIO_HEADER
+
+#include <stdio.h>
+
+namespace std {
+  using ::FILE;
+  using ::fpos_t;
+  using ::size_t;
+  using ::clearerr;
+  using ::fgets;
+  using ::fscanf;
+  using ::gets;
+  using ::rename;
+  using ::tmpfile;
+  using ::fclose;
+  using ::fopen;
+  using ::fseek;
+  using ::perror;
+  using ::rewind;
+  using ::tmpnam;
+  using ::feof;
+  using ::fprintf;
+  using ::fsetpos;
+  using ::printf;
+  using ::scanf;
+  using ::ungetc;
+  using ::ferror;
+  using ::fputc;
+  using ::ftell;
+  using ::putc;
+  using ::setbuf;
+  using ::vfprintf;
+  using ::fflush;
+  using ::fputs;
+  using ::fwrite;
+  using ::putchar;
+  using ::setvbuf;
+  using ::vprintf;
+  using ::fgetc;
+  using ::fread;
+  using ::getc;
+  using ::puts;
+  using ::sprintf;
+  using ::vsprintf;
+  using ::fgetpos;
+  using ::freopen;
+  using ::getchar;
+  using ::remove;
+  using ::sscanf;
+}
+
+#endif // CSTDIO_HEADER

simgear/compatibility/cstdlib

@@ -0,0 +1,43 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDLIB_HEADER
+#define __CSTDLIB_HEADER
+
+#include <stdlib.h>
+
+namespace std {
+  using ::abort;
+  using ::atexit;
+  using ::exit;
+  using ::getenv;
+  using ::system;
+  using ::calloc;
+  using ::malloc;
+  using ::free;
+  using ::realloc;
+  using ::atol;
+  using ::mblen;
+  using ::strtod;
+  using ::wctomb;
+  using ::atof;
+  using ::mbstowcs;
+  using ::strtol;
+  using ::wcstombs;
+  using ::atoi;
+  using ::mbtowc;
+  using ::strtoul;
+  using ::bsearch;
+  using ::qsort;
+  using ::div_t;
+  using ::ldiv_t;
+  using ::abs;
+  using ::labs;
+  using ::srand;
+  using ::div;
+  using ::ldiv;
+  using ::rand;
+}
+
+#endif // CSTDLIB_HEADER

simgear/compatibility/cstring

@@ -0,0 +1,36 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTRING_HEADER
+#define __CSTRING_HEADER
+
+#include <string.h>
+
+namespace std {
+  using ::size_t;
+  using ::memchr;
+  using ::strcat;
+  using ::strcspn;
+  using ::strncpy;
+  using ::strtok;
+  using ::memcmp;
+  using ::strchr;
+  using ::strerror;
+  using ::strpbrk;
+  using ::strxfrm;
+  using ::memcpy;
+  using ::strcmp;
+  using ::strlen;
+  using ::strrchr;
+  using ::memmove;
+  using ::strcoll;
+  using ::strncat;
+  using ::strspn;
+  using ::memset;
+  using ::strcpy;
+  using ::strncmp;
+  using ::strstr;
+}
+
+#endif // CSTRING_HEADER

simgear/compatibility/ctime

@@ -0,0 +1,26 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CTIME_HEADER
+#define __CTIME_HEADER
+
+#include <time.h>
+
+namespace std {
+  using ::size_t;
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+  using ::asctime;
+  using ::clock;
+  using ::difftime;
+  using ::localtime;
+  using ::strftime;
+  using ::ctime;
+  using ::gmtime;
+  using ::mktime;
+  using ::time;
+}
+
+#endif // CTIME_HEADER

simgear/compatibility/cwchar

@@ -0,0 +1,156 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CWCHAR_HEADER
+#define __CWCHAR_HEADER
+
+#include <wchar.h>
+
+namespace std {
+  using ::mbstate_t;
+  using ::wint_t;
+  using ::size_t;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::btowc;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::getwchar;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::ungetwc;
+#endif
+  using ::wcscpy;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wcsrtombs;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemchr;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fgetwc;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbrlen;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::vfwprintf;
+#endif
+#endif
+  using ::wcscspn;
+  using ::wcsspn;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemcmp;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fgetws;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbrtowc;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::vswprintf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::wcsftime;
+#endif
+  using ::wcsstr;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemcpy;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fputwc;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbsinit;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::vwprintf;
+#endif
+#endif
+  using ::wcslen;
+  using ::wcstod;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemmove;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fputws;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbsrtowcs;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wcrtomb;
+#endif
+  using ::wcsncat;
+  using ::wcstok;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemset;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__DECCXX_VER) && __DECCXX_VER <= 60290024)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::fwide;
+#endif
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::putwc;
+#endif
+  using ::wcscat;
+  using ::wcsncmp;
+  using ::wcstol;
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wprintf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::fwprintf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::putwchar;
+#endif
+  using ::wcschr;
+  using ::wcsncpy;
+  using ::wcstoul;
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wscanf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::fwscanf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::swprintf;
+#endif
+#endif
+  using ::wcscmp;
+  using ::wcspbrk;
+  using ::wcsxfrm;
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::getwc;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::swscanf;
+#endif
+#endif
+  using ::wcscoll;
+  using ::wcsrchr;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wctob;
+#endif
+}
+
+#endif // CWCHAR_HEADER

simgear/compatibility/cwctype

@@ -0,0 +1,39 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CWCTYPE_HEADER
+#define __CWCTYPE_HEADER
+
+#include <wctype.h>
+
+namespace std {
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wctrans_t;
+#endif
+  using ::wctype_t;
+  using ::wint_t;
+  using ::iswalnum;
+  using ::iswctype;
+  using ::iswlower;
+  using ::iswspace;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::towctrans;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wctrans;
+#endif
+  using ::iswalpha;
+  using ::iswdigit;
+  using ::iswprint;
+  using ::iswupper;
+  using ::towlower;
+  using ::wctype;
+  using ::iswcntrl;
+  using ::iswgraph;
+  using ::iswpunct;
+  using ::iswxdigit;
+  using ::towupper;
+}
+
+#endif // CWCTYPE_HEADER

simgear/compatibility/fstream

@@ -0,0 +1,19 @@
+
+#ifndef __SG_FSTREAM
+#define __SG_FSTREAM 1
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# include <fstream.h>
+
+  namespace std {
+    using ::fstream;
+    using ::ifstream;
+    using ::ofstream;
+  };
+
+
+# endif
+
+#endif // !__SG_FSTREAM
+

simgear/compatibility/iomanip

@@ -0,0 +1,14 @@
+
+#ifndef __SG_IOMANIP
+#define __SG_IOMANIP 1
+
+# include <iomanip.h>
+
+namespace std {
+   using ::setw;
+
+   inline int  setfill(int f) { ::setfill(f); }
+};
+
+#endif // !__SG_IOMANIP
+

simgear/compatibility/iostream

@@ -0,0 +1,53 @@
+
+#ifndef __SG_IOSTREAM
+#define __SG_IOSTREAM 1
+
+# include <fstream>
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# include <iostream.h>
+
+  class ios_base : public ios {
+  public:
+
+    typedef int  openmode;
+    typedef int  seekdir;
+
+    enum { binary = 0 };
+  };
+
+  namespace std {
+    using ::cin;
+    using ::cout;
+    using ::cerr;
+    using ::clog;
+    using ::endl;
+
+    using ::ios;
+    using ::ios_base;
+    using ::iostream;
+    using ::istream;
+    using ::ostream;
+
+    using ::dec;
+    using ::oct;
+    using ::hex;
+
+    enum  { skipws=ios::skipws,
+            left=ios::left, right=ios::right, internal=ios::internal,
+            showbase=ios::showbase, showpoint=ios::showpoint,
+            uppercase=ios::uppercase, showpos=ios::showpos,
+            scientific=ios::scientific, fixed=ios::fixed,
+            unitbuf=ios::unitbuf, stdio=ios::stdio
+#if _BOOL && __EDG_ABI_COMPATIBILITY_VERSION>227 /* bool support */
+            ,boolalpha=ios::boolalpha
+#endif /* bool support */
+          };
+
+  };
+
+# endif
+
+#endif // !__SG_IOSTREAM
+

simgear/compatibility/istream

@@ -0,0 +1,17 @@
+
+#ifndef __SG_ISTREAM
+#define __SG_ISTREAM 1
+
+# include <iostream>
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# include <stream.h>
+# include <string>
+
+  using std::getline;
+
+# endif
+
+#endif // !__SG_ISTREAM
+

simgear/compatibility/iterator

@@ -0,0 +1,8 @@
+
+#ifndef __SG_ITERATOR
+#define __SG_ITERATOR 1
+
+# include <iterator.h>
+
+#endif // !__SG_ITERATOR
+

simgear/compatibility/new

@@ -0,0 +1,12 @@
+
+#ifndef __SG_NEW
+#define __SG_NEW 1
+
+#if defined(sgi) && !defined(__GNUC__)
+
+# include <new.h>
+
+#endif
+
+#endif // !__SG_NEW
+

simgear/compatibility/sstream

@@ -0,0 +1,23 @@
+
+#ifndef __SG_SSTREAM
+#define __SG_SSTREAM 1
+
+# include <iostream>
+# include <strstream>
+# include <string>
+
+namespace std {
+
+   class ostringstream : public ostrstream {
+   public:
+      std::string str() {  return string(ostrstream::str()); }
+   };
+
+
+   class istringstream : public istrstream {
+   };
+
+};
+
+#endif // !__SG_SSTREAM
+

simgear/compatibility/streambuf

@@ -0,0 +1,38 @@
+
+#ifndef __SG_STREAMBUF
+#define __SG_STREAMBUF 1
+
+# include <iostream>
+# include <char_traits.h>
+
+//
+// Until we find a good way to rename the original streambuf class
+// and derive our own streambuf class from that, define this variable
+// for now so the code can inherit our streambuf class instead.
+//
+# define SG_NEED_STREAMBUF_HACK  1
+
+class __streambuf : virtual public streambuf {
+public:
+
+  typedef std::char_traits<char>            traits_type;
+  typedef std::char_traits<char>::int_type  int_type;
+
+  typedef streampos  pos_type;
+  typedef streamoff  off_type;
+};
+
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# define pubsync  sync
+
+  namespace std {
+    using ::streambuf;
+    using ::streampos;
+    using ::streamoff;
+  };
+# endif
+
+#endif // !__SG_STREAMBUF
+

simgear/compatibility/strstream

@@ -0,0 +1,20 @@
+
+#ifndef __SG_STRSTREAM
+#define __SG_STRSTREAM 1
+
+# include <strstream.h>
+
+# if defined(sgi) && !defined(__GNUC__)
+
+  namespace std {
+    using ::ends;
+
+    using ::strstream;
+    using ::istrstream;
+    using ::ostrstream;
+  };
+
+# endif
+
+#endif // !__SG_STRSTREAM
+

simgear/compiler.h

@@ -290,29 +290,27 @@
 #if defined ( sgi ) && !defined( __GNUC__ )
 #  define SG_HAVE_NATIVE_SGI_COMPILERS
 
+#include <simgear/compatibility/IRIX>
+
 #  define SG_EXPLICIT_FUNCTION_TMPL_ARGS
+#  define SG_CLASS_PARTIAL_SPECIALIZATION
 #  define SG_NEED_AUTO_PTR
 #  define SG_MEMBER_TEMPLATES
 #  define SG_NAMESPACES
 #  define SG_HAVE_STD
-#  define SG_CLASS_PARTIAL_SPECIALIZATION
+#  define SG_HAVE_STREAMBUF
 #  define SG_HAVE_TRAITS
+#  define SG_HAVE_STD_INCLUDES
 
 #  define STL_ALGORITHM  <algorithm>
 #  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip.h>
-#  define STL_IOSTREAM   <iostream.h>
-#  define STL_ITERATOR   <iterator.h>
-#  define STL_FSTREAM    <fstream.h>
+#  define STL_IOMANIP    <iomanip>
+#  define STL_IOSTREAM   <iostream>
+#  define STL_ITERATOR   <iterator>
+#  define STL_FSTREAM    <fstream>
 #  define STL_STDEXCEPT  <stdexcept>
 #  define STL_STRING     <string>
-#  define STL_STRSTREAM  <strstream.h>
-
-// #  define __STL_FUNCTION_TMPL_PARTIAL_ORDER
-// typedef void PFNGLPOINTPARAMETERFEXTPROC
-
-#define glPointParameterfEXT	glPointParameterfSGIS
-#define glPointParameterfvEXT	glPointParameterfvSGIS
+#  define STL_STRSTREAM  <strstream>
 
 #pragma set woff 1001,1012,1014,1116,1155,1172,1174
 #pragma set woff 1401,1460,1551,1552,1681
@@ -321,7 +319,7 @@
 #pragma set woff 1682,3303
 #endif
 
-#  define SG_COMPILER_STR "SGI Irix compiler version " SG_STRINGIZE(_COMPILER_VERSION)
+#  define SG_COMPILER_STR "SGI MipsPro compiler version " SG_STRINGIZE(_COMPILER_VERSION)
 
 #endif // Native SGI compilers
 

simgear/debug/debug_types.h

@@ -23,7 +23,8 @@ typedef enum {
     SG_IO        = 0x00001000,
     SG_CLIPPER   = 0x00002000,
     SG_NETWORK   = 0x00004000,
-    SG_UNDEFD    = 0x00008000, // For range checking
+    SG_ATC       = 0x00008000,
+    SG_UNDEFD    = 0x00010000, // For range checking
 
     SG_ALL     = 0xFFFFFFFF
 } sgDebugClass;
@@ -33,11 +34,12 @@ typedef enum {
  * Define the possible logging priorities (and their order).
  */
 typedef enum {
-    SG_BULK,	    // For frequent messages
-    SG_DEBUG, 	    // Less frequent debug type messages
-    SG_INFO,        // Informatory messages
-    SG_WARN,	    // Possible impending problem
-    SG_ALERT       // Very possible impending problem
+    SG_BULK = 1,       // For frequent messages
+    SG_DEBUG,          // Less frequent debug type messages
+    SG_INFO,           // Informatory messages
+    SG_WARN,           // Possible impending problem
+    SG_ALERT           // Very possible impending problem
     // SG_EXIT,        // Problem (no core)
     // SG_ABORT        // Abandon ship (core)
 } sgDebugPriority;
+

simgear/debug/logstream.hxx

@@ -28,11 +28,6 @@
 
 #include <simgear/compiler.h>
 
-// At least Irix needs this
-#ifdef SG_HAVE_NATIVE_SGI_COMPILERS
-#include <char_traits.h>
-#endif
-
 #ifdef SG_HAVE_STD_INCLUDES
 # include <streambuf>
 # include <iostream>
@@ -43,14 +38,11 @@
 
 #include <simgear/debug/debug_types.h>
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(streambuf);
 SG_USING_STD(ostream);
+SG_USING_STD(cout);
 SG_USING_STD(cerr);
 SG_USING_STD(endl);
-#else
-SG_USING_STD(char_traits);
-#endif
 
 #ifdef __MWERKS__
 SG_USING_STD(iostream);
@@ -69,7 +61,11 @@ SG_USING_STD(iostream);
  * messages at runtime. Only messages with priority >= logbuf::logPriority
  * and debugClass == logbuf::logClass are output.
  */
+#ifdef SG_NEED_STREAMBUF_HACK
+class logbuf : public __streambuf
+#else
 class logbuf : public streambuf
+#endif
 {
 public:
 

simgear/ephemeris/Makefile.am

@@ -4,7 +4,7 @@ lib_LIBRARIES = libsgephem.a
 
 include_HEADERS = \
 	celestialBody.hxx \
-        ephemeris.hxx \
+	ephemeris.hxx \
 	jupiter.hxx \
 	mars.hxx \
 	mercury.hxx \

simgear/ephemeris/ephemeris.cxx

@@ -23,6 +23,8 @@
 // $Id$
 
 
+#include <iostream>
+
 #include "ephemeris.hxx"
 
 
@@ -37,6 +39,10 @@ SGEphemeris::SGEphemeris( const string &path ) {
     saturn = new Saturn;
     uranus = new Uranus;
     neptune = new Neptune;
+    nplanets = 7;
+    for ( int i = 0; i < nplanets; ++i ) {
+        sgdSetVec3( planets[i], 0.0, 0.0, 0.0 );
+    }
     stars = new SGStarData( SGPath(path) );
 }
 

simgear/ephemeris/stardata.cxx

@@ -27,7 +27,7 @@
 
 #include "stardata.hxx"
 
-#if defined (_MSC_VER) || defined (SG_HAVE_NATIVE_SGI_COMPILERS)
+#if defined (_MSC_VER)
   SG_USING_STD(getline);
 #endif
 

simgear/io/Makefile.am

@@ -22,12 +22,6 @@ libsgio_a_SOURCES = \
 
 INCLUDES = -I$(top_srcdir)
 
-if IS_MINGW
-NETWORK_LIB = -lwsock32
-else
-NETWORK_LIB =
-endif
-
 noinst_PROGRAMS = decode_binobj socktest lowtest tcp_server tcp_client
 
 tcp_server_SOURCES = tcp_server.cxx
@@ -37,8 +31,9 @@ tcp_server_LDADD = \
 	$(top_builddir)/simgear/debug/libsgdebug.a \
 	$(top_builddir)/simgear/bucket/libsgbucket.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
-	$(top_builddir)/simgear/xml/libsgxml.a \
-	-lplibnet -lplibul -lz $(NETWORK_LIB)
+	-lplibnet -lplibul -lz \
+	$(network_LIBS) \
+	$(base_LIBS)
 
 tcp_client_SOURCES = tcp_client.cxx
 
@@ -47,18 +42,20 @@ tcp_client_LDADD = \
 	$(top_builddir)/simgear/debug/libsgdebug.a \
 	$(top_builddir)/simgear/bucket/libsgbucket.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
-        $(top_builddir)/simgear/xml/libsgxml.a \
-	-lplibnet -lplibul -lz $(NETWORK_LIB)
+	-lplibnet -lplibul -lz \
+	$(network_LIBS) \
+	$(base_LIBS)
 
 socktest_SOURCES = socktest.cxx
 
 socktest_LDADD = \
 	$(top_builddir)/simgear/bucket/libsgbucket.a \
-        $(top_builddir)/simgear/io/libsgio.a \
+	$(top_builddir)/simgear/io/libsgio.a \
 	$(top_builddir)/simgear/debug/libsgdebug.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
-	$(top_builddir)/simgear/xml/libsgxml.a \
-	-lplibnet -lplibul -lz $(NETWORK_LIB)
+	-lplibnet -lplibul -lz \
+	$(network_LIBS) \
+	$(base_LIBS)
 
 lowtest_SOURCES = lowtest.cxx
 
@@ -69,8 +66,7 @@ decode_binobj_SOURCES = decode_binobj.cxx
 
 decode_binobj_LDADD = \
 	$(top_builddir)/simgear/io/libsgio.a \
-        $(top_builddir)/simgear/bucket/libsgbucket.a \
-        $(top_builddir)/simgear/misc/libsgmisc.a \
-        $(top_builddir)/simgear/debug/libsgdebug.a \
-	$(top_builddir)/simgear/xml/libsgxml.a \
-	-lz
+	$(top_builddir)/simgear/bucket/libsgbucket.a \
+	$(top_builddir)/simgear/misc/libsgmisc.a \
+	$(top_builddir)/simgear/debug/libsgdebug.a \
+	$(base_LIBS) -lz

simgear/io/decode_binobj.cxx

@@ -3,12 +3,10 @@
 #include <unistd.h>
 #include STL_IOSTREAM
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
+#include "sg_binobj.hxx"
+
 SG_USING_STD(cout);
 SG_USING_STD(endl);
-#endif
-
-#include "sg_binobj.hxx"
 
 
 int main( int argc, char **argv ) {

simgear/io/lowtest.cxx

@@ -3,16 +3,14 @@
 #include STL_IOSTREAM
 #include "lowlevel.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
-SG_USING_STD(cout);
-SG_USING_STD(endl);
-#endif
-
 
 static const int sgEndianTest = 1;
 #define sgIsLittleEndian (*((char *) &sgEndianTest ) != 0)
 #define sgIsBigEndian    (*((char *) &sgEndianTest ) == 0)
 
+SG_USING_STD(cout);
+SG_USING_STD(endl);
+
 
 int main() {
     cout << "This machine is ";

simgear/io/sg_binobj.cxx

@@ -27,6 +27,7 @@
 #endif
 
 #include <simgear/compiler.h>
+#include <simgear/debug/logstream.hxx>
 
 #include <stdio.h>
 #include <time.h>
@@ -43,11 +44,6 @@
 SG_USING_STD( string );
 SG_USING_STD( vector );
 
-#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
-SG_USING_STD( cout );
-SG_USING_STD( endl );
-#endif
-
 
 enum {
     SG_BOUNDING_SPHERE = 0,
@@ -93,7 +89,7 @@ public:
 	while ( size < s ) {
 	    size *= 2;
 	}
-	cout << "Creating a new buffer of size = " << size << endl;
+        SG_LOG(SG_EVENT, SG_DEBUG, "Creating a new buffer of size = " << size);
 	ptr = new char[size];
     }
 
@@ -111,7 +107,7 @@ public:
 	    while ( size < s ) {
 		size *= 2;
 	    }
-	    cout << "resizing buffer to size = " << size << endl;
+            SG_LOG(SG_EVENT, SG_DEBUG, "resizing buffer to size = " << size);
 	    ptr = new char[size];
 	}
     }
@@ -325,8 +321,8 @@ bool SGBinObject::read_bin( const string& file ) {
     if ( (fp = gzopen( file.c_str(), "rb" )) == NULL ) {
 	string filegz = file + ".gz";
 	if ( (fp = gzopen( filegz.c_str(), "rb" )) == NULL ) {
-	    cout << "ERROR: opening " << file << " or " << filegz
-	         << "for reading!" << endl;
+            SG_LOG( SG_EVENT, SG_ALERT,
+               "ERROR: opening " << file << " or " << filegz << "for reading!");
 
 	    return false;
 	}
@@ -364,7 +360,7 @@ bool SGBinObject::read_bin( const string& file ) {
     local_tm = localtime( &calendar_time );
     char time_str[256];
     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
-    cout << "File created on " << time_str << endl;
+    SG_LOG( SG_EVENT, SG_DEBUG, "File created on " << time_str);
 #endif
 
     // read number of top level objects

simgear/io/sg_serial.hxx

@@ -55,7 +55,7 @@ class SGSerial : public SGIOChannel {
 
     string device;
     string baud;
-    FGSerialPort port;
+    SGSerialPort port;
 
     char save_buf[ 2 * SG_IO_MAX_MSG_SIZE ];
     int save_len;

simgear/io/sg_socket.cxx

@@ -54,7 +54,7 @@ SGSocket::SGSocket( const string& host, const string& port_,
     {
 	is_tcp = true;
     }
-    else if ( style != (string)"udp" )
+    else if ( style != "udp" )
     {
 	SG_LOG( SG_IO, SG_ALERT,
 		"Error: SGSocket() unknown style = " << style );

simgear/io/socktest.cxx

@@ -6,15 +6,14 @@
 #include "sg_socket.hxx"
 #include "lowlevel.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
-SG_USING_STD(cout);
-SG_USING_STD(endl);
-#endif
-
 static const int sgEndianTest = 1;
 #define sgIsLittleEndian (*((char *) &sgEndianTest ) != 0)
 #define sgIsBigEndian    (*((char *) &sgEndianTest ) == 0)
 
+SG_USING_STD(cout);
+SG_USING_STD(endl);
+
+
 int main() {
 
     if ( sgIsLittleEndian ) {

simgear/io/tcp_client.cxx

@@ -11,9 +11,6 @@
 
 #include "sg_socket.hxx"
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
-using std::cout;
-#endif
 
 class TcpClient
 {

simgear/io/tcp_server.cxx

@@ -5,10 +5,8 @@
 
 #include "sg_socket.hxx"
 
-using std::string;
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
-using std::cout;
-#endif
+SG_USING_STD(string);
+SG_USING_STD(cout);
 
 class TcpServer
 {

simgear/magvar/Makefile.am

@@ -12,6 +12,8 @@ noinst_PROGRAMS = testmagvar
 
 testmagvar_SOURCES = testmagvar.cxx
 
-testmagvar_LDADD = $(top_builddir)/simgear/magvar/libsgmagvar.a
+testmagvar_LDADD = \
+	$(top_builddir)/simgear/magvar/libsgmagvar.a \
+	$(base_LIBS)
 
 INCLUDES = -I$(top_srcdir)

simgear/math/Makefile.am

@@ -12,7 +12,8 @@ include_HEADERS = \
 	sg_memory.h \
 	sg_random.h \
 	sg_types.hxx \
-	vector.hxx
+	vector.hxx \
+	fastmath.hxx
 
 EXTRA_DIST = linintp2.h linintp2.inl sphrintp.h sphrintp.inl
 
@@ -22,6 +23,7 @@ libsgmath_a_SOURCES = \
 	polar3d.cxx \
 	sg_geodesy.cxx \
 	sg_random.c \
-	vector.cxx
+	vector.cxx \
+	fastmath.cxx
 
 INCLUDES = -I$(top_srcdir)

simgear/math/fastmath.cxx

@@ -0,0 +1,65 @@
+/*
+ * \file fastmath.cxx
+ * fast mathematics routines.
+ *
+ * Refferences:
+ *
+ * A Fast, Compact Approximation of the Exponential Function
+ * Nicol N. Schraudolph
+ * IDSIA, Lugano, Switzerland
+ * http://www.inf.ethz.ch/~schraudo/pubs/exp.pdf
+ *
+ * Fast log() Function, by Laurent de Soras:
+ * http://www.flipcode.com/cgi-bin/msg.cgi?showThread=Tip-Fastlogfunction&forum=totd&id=-1
+ *
+ */
+
+/*
+ * $Id$
+ */
+
+
+
+#include "fastmath.hxx"
+
+/**
+ * This function is on avarage 9 times faster than the system exp() function
+ * and has an error of about 1.5%
+ */
+static union {
+    double d;
+    struct {
+#if BYTE_ORDER == BIG_ENDIAN
+        int i, j;
+#else
+        int j, i;
+#endif
+    } n;
+} _eco;
+
+double fast_exp(double val) {
+    const double a = 1048576/M_LN2;
+    const double b_c = 1072632447; /* 1072693248 - 60801 */
+
+    _eco.n.i = a*val + b_c;
+
+    return _eco.d;
+}
+
+
+/**
+ * While we're on the subject, someone might have use for these as well?
+ * Float Shift Left and Float Shift Right. Do what you want with this.
+ */
+void fast_BSL(float &x, register unsigned long shiftAmount) {
+
+	*(unsigned long*)&x+=shiftAmount<<23;
+
+}
+
+void fast_BSR(float &x, register unsigned long shiftAmount) {
+
+	*(unsigned long*)&x-=shiftAmount<<23;
+
+}
+

simgear/math/fastmath.hxx

@@ -0,0 +1,69 @@
+/*
+ * \file fastmath.hxx
+ * fast mathematics routines.
+ *
+ * Refferences:
+ *
+ * A Fast, Compact Approximation of the Exponential Function
+ * Nicol N. Schraudolph
+ * IDSIA, Lugano, Switzerland
+ * http://www.inf.ethz.ch/~schraudo/pubs/exp.pdf
+ *
+ * Fast log() Function, by Laurent de Soras:
+ * http://www.flipcode.com/cgi-bin/msg.cgi?showThread=Tip-Fastlogfunction&forum=totd&id=-1
+ *
+ */
+
+/*
+ * $Id$
+ */
+
+#ifndef _SG_FMATH_HXX
+#define _SG_FMATH_HXX 1
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+#ifdef _MSC_VER
+#define  _USE_MATH_DEFINES
+#endif
+#include <math.h>
+
+
+double fast_exp(double val);
+
+void fast_BSL(float &x, register unsigned long shiftAmount);
+void fast_BSR(float &x, register unsigned long shiftAmount);
+
+inline float fast_log2 (float val)
+{
+   int * const    exp_ptr = reinterpret_cast <int *> (&val);
+   int            x = *exp_ptr;
+   const int      log_2 = ((x >> 23) & 255) - 128;
+   x &= ~(255 << 23);
+   x += 127 << 23;
+   *exp_ptr = x;
+
+   val = ((-1.0f/3) * val + 2) * val - 2.0f/3;   // (1)
+
+   return (val + log_2);
+}
+
+/**
+ * This function is about 3 times faster than the system log() function
+ * and has an error of about 0.01%
+ */
+inline float fast_log (const float &val)
+{
+   return (fast_log2 (val) * 0.69314718f);
+}
+
+inline float fast_log10 (const float &val)
+{
+   return (fast_log2(val) / 3.321928095f);
+}
+
+
+#endif // !_SG_FMATH_HXX
+

simgear/math/interpolater.cxx

@@ -30,7 +30,6 @@
 
 #include STL_STRING
 
-// depricated - #include <simgear/sg_zlib.h>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/sgstream.hxx>
 

simgear/math/linintp2.inl

@@ -48,7 +48,7 @@ mgcLinInterp2D<T>::mgcLinInterp2D (int _numPoints, double* x, double* y,
         return;
     }
 
-    cout << "[ 20%] allocating memory                                              \r";
+    // cout << "[ 20%] allocating memory                                              \r";
 
     point = new double*[numPoints];
     tmppoint = new double*[numPoints+3];
@@ -66,7 +66,7 @@ mgcLinInterp2D<T>::mgcLinInterp2D (int _numPoints, double* x, double* y,
 	f[i] = _f[i];
     }
 
-    cout << "[ 30%] creating delaunay diagram                                      \r";
+    // cout << "[ 30%] creating delaunay diagram                                      \r";
 
     Delaunay2D();
 }
@@ -279,7 +279,7 @@ int mgcLinInterp2D<T>::Delaunay2D ()
     nts = 1;  // number of triangles
     i4 = 1;
 
-    cout << "[ 40%] create triangulation                                     \r";
+    // cout << "[ 40%] create triangulation                                     \r";
 
     // compute triangulation
     for (i0 = 0; i0 < numPoints; i0++)
@@ -372,7 +372,7 @@ Corner3:;
     }
 
     // count the number of triangles
-    cout << "[ 50%] count the number of triangles                                  \r";
+    // cout << "[ 50%] count the number of triangles                                  \r";
 
     numTriangles = 0;
     i0 = -1;
@@ -394,7 +394,7 @@ Corner3:;
     }
 
     // create the triangles
-    cout << "[ 60%] create the triangles                                         \r";
+    // cout << "[ 60%] create the triangles                                         \r";
 
     triangle = new Triangle[numTriangles];
 
@@ -428,7 +428,7 @@ Corner3:;
     }
 
     // build edge table
-    cout << "[ 70%] build the edge table                                       \r";
+    // cout << "[ 70%] build the edge table                                       \r";
 
     numEdges = 0;
     edge = new Edge[3*numTriangles];
@@ -436,8 +436,8 @@ Corner3:;
     int j, j0, j1;
     for (i = 0; i < numTriangles; i++)
     {
-	if ( (i%500) == 0)
-	    cout << "[ 7" << 10*i/numTriangles << "%] build the edge table                                       \r";
+	// if ( (i%500) == 0)
+	    // cout << "[ 7" << 10*i/numTriangles << "%] build the edge table                                       \r";
 
         Triangle& t = triangle[i];
 
@@ -470,7 +470,7 @@ Corner3:;
     }
 
     // establish links between adjacent triangles
-    cout << "[ 80%] establishing links between adjacent triangles                                       \r";
+    // cout << "[ 80%] establishing links between adjacent triangles                                       \r";
 
     for (i = 0; i < numEdges; i++)
     {
@@ -494,7 +494,7 @@ ExitDelaunay:;
     delete[] ccr[0];
     delete[] ccr;
 
-    cout << "[ 90%] finsishes delauney triangulation                            \r";
+    // cout << "[ 90%] finsishes delauney triangulation                            \r";
 
     return result;
 }

simgear/math/point3d.hxx

@@ -61,10 +61,8 @@
 SG_USING_NAMESPACE(std);
 #endif
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(ostream);
 SG_USING_STD(istream);
-#endif
 
 
 const double fgPoint3_Epsilon = 0.0000001;

simgear/math/sg_geodesy.cxx

@@ -27,12 +27,10 @@
 #include "localconsts.hxx"
 
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(cout);
-#endif
 
 
-#define DOMAIN_ERR_DEBUG 1
+// #define DOMAIN_ERR_DEBUG 1
 
 
 // sgGeocToGeod(lat_geoc, radius, *lat_geod, *alt, *sea_level_r)
@@ -47,8 +45,8 @@ SG_USING_STD(cout);
 //                      local vertical (surface normal) of C.G. (meters)
 
 
-void sgGeocToGeod( double lat_geoc, double radius, double
-		   *lat_geod, double *alt, double *sea_level_r )
+void sgGeocToGeod( const double& lat_geoc, const double& radius,
+                   double *lat_geod, double *alt, double *sea_level_r )
 {
 #ifdef DOMAIN_ERR_DEBUG
     errno = 0;			// start with error zero'd
@@ -134,7 +132,7 @@ void sgGeocToGeod( double lat_geoc, double radius, double
 //
 
 
-void sgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
+void sgGeodToGeoc( const double& lat_geod, const double& alt, double *sl_radius,
 		      double *lat_geoc )
 {
     double lambda_sl, sin_lambda_sl, cos_lambda_sl, sin_mu, cos_mu, px, py;
@@ -184,7 +182,7 @@ void sgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
 
 // for WGS_84 a = 6378137.000, rf = 298.257223563;
 
-static double M0( double e2 ) {
+static inline double M0( double e2 ) {
     //double e4 = e2*e2;
     return GEOD_INV_PI*(1.0 - e2*( 1.0/4.0 + e2*( 3.0/64.0 + 
 						  e2*(5.0/256.0) )))/2.0;
@@ -193,8 +191,10 @@ static double M0( double e2 ) {
 
 // given, alt, lat1, lon1, az1 and distance (s), calculate lat2, lon2
 // and az2.  Lat, lon, and azimuth are in degrees.  distance in meters
-int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1, 
-			double s, double *lat2, double *lon2,  double *az2 )
+int geo_direct_wgs_84 ( const double& alt, const double& lat1,
+                        const double& lon1, const double& az1,
+                        const double& s, double *lat2, double *lon2,
+                        double *az2 )
 {
     double a = 6378137.000, rf = 298.257223563;
     double RADDEG = (GEOD_INV_PI)/180.0, testv = 1.0E-10;
@@ -275,7 +275,8 @@ int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1,
     } else {			// phi1 == 90 degrees, polar origin
 	double dM = a*M0(e2) - s;
 	double paz = ( phi1 < 0.0 ? 180.0 : 0.0 );
-	return geo_direct_wgs_84( alt, 0.0, lon1, paz, dM,lat2,lon2,az2 );
+        double zero = 0.0f;
+	return geo_direct_wgs_84( alt, zero, lon1, paz, dM, lat2, lon2, az2 );
     } 
 }
 
@@ -283,8 +284,10 @@ int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1,
 // given alt, lat1, lon1, lat2, lon2, calculate starting and ending
 // az1, az2 and distance (s).  Lat, lon, and azimuth are in degrees.
 // distance in meters
-int geo_inverse_wgs_84( double alt, double lat1, double lon1, double lat2,
-			double lon2, double *az1, double *az2, double *s )
+int geo_inverse_wgs_84( const double& alt, const double& lat1,
+                        const double& lon1, const double& lat2,
+			const double& lon2, double *az1, double *az2,
+                        double *s )
 {
     double a = 6378137.000, rf = 298.257223563;
     int iter=0;
@@ -311,8 +314,9 @@ int geo_inverse_wgs_84( double alt, double lat1, double lon1, double lat2,
 	return 0;
     } else if( fabs(cosphi2) < testv ) {
 	// terminal point is polar
-	int k = geo_inverse_wgs_84( alt, lat1,lon1,lat1,lon1+180.0, 
-				    az1,az2,s );
+        double _lon1 = lon1 + 180.0f;
+	int k = geo_inverse_wgs_84( alt, lat1, lon1, lat1, _lon1, 
+				    az1, az2, s );
 	k = k; // avoid compiler error since return result is unused
 	*s /= 2.0;
 	*az2 = *az1 + 180.0;

simgear/math/sg_geodesy.hxx

@@ -31,8 +31,8 @@
  * @param sea_level_r (out) radius from earth center to sea level at
  *        local vertical (surface normal) of C.G. (meters)
  */
-void sgGeocToGeod( double lat_geoc, double radius, double
-		   *lat_geod, double *alt, double *sea_level_r );
+void sgGeocToGeod( const double& lat_geoc, const double& radius,
+                   double *lat_geod, double *alt, double *sea_level_r );
 
 
 /**
@@ -43,8 +43,8 @@ void sgGeocToGeod( double lat_geoc, double radius, double
  *        (add Altitude to get true distance from earth center.
  * @param lat_geoc (out) Geocentric latitude, radians, + = North
  */
-void sgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
-		      double *lat_geoc );
+void sgGeodToGeoc( const double& lat_geod, const double& alt,
+                   double *sl_radius, double *lat_geoc );
 
 
 /**
@@ -82,15 +82,28 @@ inline Point3D sgGeodToCart(const Point3D& geod) {
  * @param lon2 (out) degrees
  * @param az2 (out) return course in degrees
  */
-int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1, 
-			double s, double *lat2, double *lon2,  double *az2 );
+int geo_direct_wgs_84 ( const double& alt, const double& lat1,
+                        const double& lon1, const double& az1, 
+			const double& s, double *lat2, double *lon2,
+                        double *az2 );
 
 
-// given alt, lat1, lon1, lat2, lon2, calculate starting and ending
-// az1, az2 and distance (s).  Lat, lon, and azimuth are in degrees.
-// distance in meters
-int geo_inverse_wgs_84( double alt, double lat1, double lon1, double lat2,
-			double lon2, double *az1, double *az2, double *s );
+/**
+ * Given an altitude and two sets of (lat, lon) calculate great circle
+ * distance between them as well as the starting and ending azimuths.
+ * @param alt (in) meters
+ * @param lat1 (in) degrees
+ * @param lon1 (in) degrees
+ * @param lat2 (in) degrees
+ * @param lon2 (in) degrees
+ * @param az1 (out) start heading degrees
+ * @param az2 (out) end heading degrees
+ * @param s (out) distance meters
+ */
+int geo_inverse_wgs_84( const double& alt, const double& lat1,
+                        const double& lon1, const double& lat2,
+			const double& lon2, double *az1, double *az2,
+                        double *s );
 
 
 /***************************************************************************

simgear/math/sphrintp.inl

@@ -45,8 +45,8 @@ SphereInterpolate<T>::SphereInterpolate (int n, const double* x,
     // For complete spherical coverage, include the two antipodal points
     // (0,0,1,f(0,0,1)) and (0,0,-1,f(0,0,-1)) in the data set.
     
-    cout << "Initialising spherical interpolator.\n";
-    cout << "[  0%] Allocating memory                                           \r";
+    // cout << "Initialising spherical interpolator.\n";
+    // cout << "[  0%] Allocating memory                                           \r";
 
     theta = new double[3*n];
     phi = new double[3*n];
@@ -63,7 +63,7 @@ SphereInterpolate<T>::SphereInterpolate (int n, const double* x,
     }
     
     // use periodicity to get wrap-around in the Delaunay triangulation
-    cout << "[ 10%] copying vertices for wrap-around\r";
+    // cout << "[ 10%] copying vertices for wrap-around\r";
     int j, k;
     for (i = 0, j = n, k = 2*n; i < n; i++, j++, k++)
     {
@@ -77,7 +77,7 @@ SphereInterpolate<T>::SphereInterpolate (int n, const double* x,
     
     pInterp = new mgcLinInterp2D<T>(3*n,theta,phi,func);
 
-    cout << "[100%] Finished initialising spherical interpolator.                   \n";
+    // cout << "[100%] Finished initialising spherical interpolator.                   \n";
 }
 
 template<class T>
@@ -86,15 +86,15 @@ SphereInterpolate<T>::SphereInterpolate (int n, const sgVec2* p, const T* f)
     // Assumes (x[i],y[i],z[i]) is unit length for all 0 <= i < n.
     // For complete spherical coverage, include the two antipodal points
     // (0,0,1,f(0,0,1)) and (0,0,-1,f(0,0,-1)) in the data set.
-    cout << "Initialising spherical interpolator.\n";
-    cout << "[  0%] Allocating memory                                           \r";
+    // cout << "Initialising spherical interpolator.\n";
+    // cout << "[  0%] Allocating memory                                           \r";
 
     theta = new double[3*n];
     phi = new double[3*n];
     func = new T[3*n];
 
     // convert data to spherical coordinates
-    cout << "[ 10%] copying vertices for wrap-around                              \r";
+    // cout << "[ 10%] copying vertices for wrap-around                              \r";
 
     int i, j, k;
     for (i = 0, j = n, k = 2*n; i < n; i++, j++, k++)
@@ -114,7 +114,7 @@ SphereInterpolate<T>::SphereInterpolate (int n, const sgVec2* p, const T* f)
     
     pInterp = new mgcLinInterp2D<T>(3*n,theta,phi,func);
 
-    cout << "[100%] Finished initialising spherical interpolator.                   \n";
+    // cout << "[100%] Finished initialising spherical interpolator.                   \n";
 }
 //---------------------------------------------------------------------------
 template<class T>

simgear/metar/Dcdmtrmk.cpp

@@ -4165,7 +4165,7 @@ static bool isPtendency(char *string, Decoded_METAR *Mptr, int *NDEX)
  
    if(strlen(string) != 5)
       return FALSE;
-   else if(*string == '5' && ('0' <= *(string+1) <= '8') &&
+   else if(*string == '5' && ('0' <= *(string+1) && *(string+1) <= '8') &&
              (nisdigit(string+2,3) || strncmp(string+2,"///",3)
                                              == 0) )
    {

simgear/metar/Local.h

@@ -1096,8 +1096,8 @@ bool ccap2std(char *, Devaddr *, Diskaddr *);
  
 bool std2ccap(Devaddr *, Diskaddr *, char *);
  
-char *strupr(char *);
-char *strlwr(char *);
+//char *strupr(char *);
+//char *strlwr(char *);
 //char *strdup(char *);
 //int strcmpi(char *, char *);
  

simgear/metar/MetarReport.cpp

@@ -7,10 +7,8 @@
 #include "MetarReport.h"
 #include "Metar.h"
 
-#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(endl);
 SG_USING_STD(ostream);
-#endif
 
 CMetarReport::CMetarReport(
    char *s ) :

simgear/metar/MetarStation.cpp

@@ -8,11 +8,9 @@
 #include "MetarStation.h"
 #include <algorithm>
 
-#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(ostream);
 SG_USING_STD(cout);
 SG_USING_STD(endl);
-#endif
 
 
 double CMetarStation::decodeDMS( char *b )

simgear/metar/MetarTest/MetarLibTest.cpp

@@ -1,9 +1,18 @@
 // Metar Library  test
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include GLUT_H
+
 #include <iostream>
 #include "../MetarReport.h"
 #include "../MetarStation.h"
-#include <GL/glut.h>
 
 static char *report[] =
 {
@@ -546,4 +555,4 @@ main(
 	testMetarReport();
 	testMetarStation( argc, argv );
 	return 0;
-}
+}

simgear/misc/.cvsignore

@@ -2,3 +2,4 @@
 Makefile
 Makefile.in
 props_test
+tabbed_value_test

simgear/misc/Makefile.am

@@ -3,31 +3,28 @@ includedir = @includedir@/misc
 lib_LIBRARIES = libsgmisc.a
 
 include_HEADERS = \
-        commands.hxx \
-        exception.hxx \
-	props.hxx \
-  props_io.hxx \
 	sg_path.hxx \
 	sgstream.hxx \
 	stopwatch.hxx \
 	strutils.hxx \
+	tabbed_values.hxx \
 	texcoord.hxx \
 	zfstream.hxx
 
 libsgmisc_a_SOURCES = \
-        commands.cxx \
-        exception.cxx \
-	props.cxx \
-        props_io.cxx \
 	sg_path.cxx \
 	sgstream.cxx \
 	strutils.cxx \
+	tabbed_values.cxx \
 	texcoord.cxx \
 	zfstream.cxx
 
-noinst_PROGRAMS = props_test
+noinst_PROGRAMS = tabbed_value_test
 
-props_test_SOURCES = props_test.cxx
-props_test_LDADD = libsgmisc.a ../xml/libsgxml.a ../debug/libsgdebug.a
+tabbed_value_test_SOURCES = tabbed_values_test.cxx
+tabbed_value_test_LDADD = \
+	$(top_builddir)/simgear/misc/libsgmisc.a \
+	$(top_builddir)/simgear/xml/libsgxml.a \
+	$(top_builddir)/simgear/debug/libsgdebug.a
 
 INCLUDES = -I$(top_srcdir)

simgear/misc/sg_path.cxx

@@ -23,12 +23,33 @@
 // $Id$
 
 
+#include <simgear/compiler.h>
+
 #include <simgear_config.h>
 #include <stdio.h>
 
 #include "sg_path.hxx"
 
 
+/**
+ * define directory path separators
+ */
+
+#if defined( macintosh )
+static const char sgDirPathSep = ':';
+static const char sgDirPathSepBad = '/';
+#else
+static const char sgDirPathSep = '/';
+static const char sgDirPathSepBad = ':';
+#endif
+
+#if defined( WIN32 )
+static const char sgSearchPathSep = ';';
+#else
+static const char sgSearchPathSep = ':';
+#endif
+
+
 // If Unix, replace all ":" with "/".  If MacOS, replace all "/" with
 // ":" it should go without saying that neither of these characters
 // should be used in file or directory names.  In windoze, allow the
@@ -44,8 +65,8 @@ SGPath::fix()
 	    continue;
 	}
 #endif
-	if ( path[i] == SG_BAD_PATH_SEP ) {
-	    path[i] = SG_PATH_SEP;
+	if ( path[i] == sgDirPathSepBad ) {
+	    path[i] = sgDirPathSep;
 	}
     }
 }
@@ -83,8 +104,8 @@ void SGPath::append( const string& p ) {
     if ( path.size() == 0 ) {
 	path = p;
     } else {
-	if ( p[0] != SG_PATH_SEP ) {
-	    path += SG_PATH_SEP;
+	if ( p[0] != sgDirPathSep ) {
+	    path += sgDirPathSep;
 	}
 	path += p;
     }
@@ -104,9 +125,20 @@ void SGPath::concat( const string& p ) {
 }
 
 
+// Get the file part of the path (everything after the last path sep)
+string SGPath::file() const {
+    int index = path.rfind(sgDirPathSep);
+    if (index >= 0) {
+	return path.substr(index + 1);
+    } else {
+	return "";
+    }
+}
+  
+
 // get the directory part of the path.
-string SGPath::dir() {
-    int index = path.rfind(SG_PATH_SEP);
+string SGPath::dir() const {
+    int index = path.rfind(sgDirPathSep);
     if (index >= 0) {
 	return path.substr(0, index);
     } else {
@@ -114,6 +146,26 @@ string SGPath::dir() {
     }
 }
 
+// get the base part of the path (everything but the extension.)
+string SGPath::base() const {
+    int index = path.rfind(".");
+    if (index >= 0) {
+	return path.substr(0, index);
+    } else {
+	return "";
+    }
+}
+
+// get the extention (everything after the final ".")
+string SGPath::extension() const {
+    int index = path.rfind(".");
+    if (index >= 0) {
+	return path.substr(index + 1);
+    } else {
+	return "";
+    }
+}
+
 bool SGPath::exists() const {
     FILE* fp = fopen( path.c_str(), "r");
     if (fp == 0) {
@@ -122,3 +174,25 @@ bool SGPath::exists() const {
     fclose(fp);
     return true;
 }
+
+
+string_list sgPathSplit( const string &search_path ) {
+    string tmp = search_path;
+    string_list result;
+    result.clear();
+
+    bool done = false;
+
+    while ( !done ) {
+        int index = tmp.find(sgSearchPathSep);
+        if (index >= 0) {
+            result.push_back( tmp.substr(0, index) );
+            tmp = tmp.substr( index + 1 );
+        } else {
+            result.push_back( tmp );
+            done = true;
+        }
+    }
+
+    return result;
+}

simgear/misc/sg_path.hxx

@@ -31,21 +31,13 @@
 
 
 #include <simgear/compiler.h>
-
 #include STL_STRING
 
+#include <simgear/math/sg_types.hxx>
+
 SG_USING_STD(string);
 
 
-#ifdef macintosh
-#  define SG_PATH_SEP ':'
-#  define SG_BAD_PATH_SEP '/'
-#else
-#  define SG_PATH_SEP '/'
-#  define SG_BAD_PATH_SEP ':'
-#endif
-
-
 /**
  * A class to hide path separator difference across platforms and assist
  * in managing file system path names.
@@ -94,12 +86,30 @@ public:
      */
     void concat( const string& p );
 
+    /**
+     * Get the file part of the path (everything after the last path sep)
+     * @return file string
+     */
+    string file() const;
+  
     /**
      * Get the directory part of the path.
      * @return directory string
      */
-    string dir();
+    string dir() const;
   
+    /**
+     * Get the base part of the path (everything but the extension.)
+     * @return the base string
+     */
+    string base() const;
+
+    /**
+     * Get the extention part of the path (everything after the final ".")
+     * @return the extention string
+     */
+    string extension() const;
+
     /** Get the path string
      * @return path string
      */
@@ -123,6 +133,12 @@ private:
 };
 
 
+/**
+ * Split a directory search path into a vector of individual paths
+ */
+string_list sgPathSplit( const string &search_path );
+
+
 #endif // _SG_PATH_HXX
 
 

simgear/misc/sgstream.hxx

@@ -36,8 +36,6 @@
 
 #if defined( SG_HAVE_STD_INCLUDES )
 #  include <istream>
-#elif defined ( SG_HAVE_NATIVE_SGI_COMPILERS )
-#  include <CC/stream.h>
 #elif defined ( __BORLANDC__ )
 #  include <iostream>
 #else
@@ -49,10 +47,7 @@
 #include <simgear/misc/zfstream.hxx>
 
 SG_USING_STD(string);
-
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(istream);
-#endif
 
 
 /**

simgear/misc/tabbed_values.cxx

@@ -0,0 +1,77 @@
+#include "tabbed_values.hxx"
+
+#include "assert.h"
+
+SGTabbedValues::SGTabbedValues(const char *line) :
+	_line(line)
+{
+	assert(line);
+	_fields.push_back(const_cast<char*>(line));
+}
+
+const char* SGTabbedValues::fieldAt(const unsigned int index) const
+{
+	// we already computed that offset, cool
+	if (_fields.size() > index)
+		return _fields[index];
+
+	while (_fields.size() <= index) {
+		char* nextField = _fields.back();
+		if (*nextField=='\0') return NULL; // we went off the end
+			
+		while (*nextField != '\t') {
+			if (*nextField=='\0') return NULL; // we went off the end
+			++nextField;
+		}
+		_fields.push_back(++nextField);
+	}
+	
+	return _fields.back();
+}
+
+string SGTabbedValues::operator[](const unsigned int offset) const
+{
+	const char *data = fieldAt(offset);
+	char* endPtr = const_cast<char*>(data);
+	int len = 0;
+	while ((*endPtr != '\0') && (*endPtr != '\t')) {
+		++len;
+		++endPtr;
+	}
+	return string(fieldAt(offset), len);
+}
+
+bool SGTabbedValues::isValueAt(const unsigned int offset) const
+{
+	const char *data = fieldAt(offset);
+	return data && (*data != '\t'); // must be non-NULL and non-tab
+}
+
+char SGTabbedValues::getCharAt(const unsigned int offset) const
+{
+	const char *data = fieldAt(offset);
+	if (!data || (*data == '\t'))
+		return 0;
+	
+	return *data;
+}
+
+double SGTabbedValues::getDoubleAt(const unsigned int offset) const
+{
+	const char *data = fieldAt(offset);
+	if (!data || (*data == '\t'))
+		return 0;
+		
+	/* this is safe because strtod will stop parsing when it sees an unrecogznied
+	character, which includes tab. */	
+	return strtod(data, NULL);
+}
+
+long SGTabbedValues::getLongAt(const unsigned int offset) const
+{
+	const char *data = fieldAt(offset);
+	if (!data || (*data == '\t'))
+		return 0;
+
+	return strtol(data, NULL, 0);
+}

simgear/misc/tabbed_values.hxx

@@ -0,0 +1,36 @@
+#ifndef SG_TABBED_VALUES_HXX
+#define SG_TABBED_VALUES_HXX
+
+#include <vector>
+#include <string>
+
+#include "simgear/compiler.h"
+
+SG_USING_STD(vector);
+SG_USING_STD(string);
+
+class SGTabbedValues
+{
+public:
+	SGTabbedValues(const char* line);
+	
+	string operator[](const unsigned int) const;
+
+	bool isValueAt(const unsigned int) const;
+	
+	double getDoubleAt(const unsigned int) const;
+	char getCharAt(const unsigned int) const;
+	long getLongAt(const unsigned int) const;
+private:
+	const char* fieldAt(const unsigned int offset) const;
+
+	const char* _line;
+	
+	/** this is first character of each field, if the field is empty
+	it will be the tab character. It is lazily built as needed, so
+	if only the first field is accessed (which is a common case) we
+	don't iterative over the whole line. */
+	mutable vector<char*> _fields;
+};
+
+#endif

simgear/misc/tabbed_values_test.cxx

@@ -0,0 +1,71 @@
+////////////////////////////////////////////////////////////////////////
+// Test harness.
+////////////////////////////////////////////////////////////////////////
+
+#include <simgear/compiler.h>
+
+#include STL_IOSTREAM
+#include "tabbed_values.hxx"
+
+SG_USING_STD(cout);
+SG_USING_STD(cerr);
+SG_USING_STD(endl);
+
+
+int main (int ac, char ** av)
+{
+	const char* string1 = "Hello\tWorld\t34\tZ\t\tThere Is No Spoon";
+	
+	SGTabbedValues tv(string1);
+	
+	if (tv[0] != "Hello") {
+		cerr << "failed to read string at index 0" << endl;
+		return 1;
+	}
+	
+	if (tv[1] != "World") {
+		cerr << "failed to read string at index 1" << endl;
+		return 1;
+	}
+	
+	if (tv[2] != "34") {
+		cerr << "failed to read string at index 2" << endl;
+		return 1;
+	}
+	
+	double dval = tv.getDoubleAt(2);
+	if (dval != 34.0) {
+		cerr << "failed to read double at index 2" << endl;
+		return 2;
+	}
+	
+	char cval = tv.getCharAt(3);
+	if (cval != 'Z') {
+		cerr << "failed to read char at index 3" << endl;
+		return 1;
+	}
+	
+	cval = tv.getCharAt(0);
+	if (cval != 'H') {
+		cerr << "failed to read char at index 0" << endl;
+		return 1;
+	}
+	
+	if (tv.isValueAt(4)) {
+		cerr << "didn't identify skipped value correctly" << endl;
+		return 3;
+	}
+	
+	if (!tv.isValueAt(3)) {
+		cerr << "didn't identify present value correctly" << endl;
+		return 3;
+	}
+	
+	if (tv[5] != "There Is No Spoon") {
+		cerr << "failed to read string at index 5 (got [" << tv[5] << "]" << endl;
+		return 1;
+	}
+	
+	cout << "all tests passed successfully!" << endl;
+	return 0;
+}

simgear/misc/texcoord.cxx

@@ -140,8 +140,15 @@ enter this in the official comments in case I forget again. :-)
 
 */
 
+#include <simgear/compiler.h>
+
+// #include STL_IOSTREAM
+
 #include "texcoord.hxx"
 
+// SG_USING_STD(cout);
+// SG_USING_STD(endl);
+
 
 #define FG_STANDARD_TEXTURE_DIMENSION 1000.0 // meters
 #define MAX_TEX_COORD 8.0
@@ -149,9 +156,10 @@ enter this in the official comments in case I forget again. :-)
 
 
 // return the basic unshifted/unmoded texture coordinate for a lat/lon
-inline Point3D basic_tex_coord( const Point3D& p, 
-				double degree_width, double degree_height,
-				double scale )
+static inline Point3D basic_tex_coord( const Point3D& p, 
+                                       double degree_width,
+                                       double degree_height,
+                                       double scale )
 {
     return Point3D( p.x() * ( degree_width * scale / 
 			      FG_STANDARD_TEXTURE_DIMENSION ),
@@ -163,7 +171,7 @@ inline Point3D basic_tex_coord( const Point3D& p,
 
 // traverse the specified fan/strip/list of vertices and attempt to
 // calculate "none stretching" texture coordinates
-point_list calc_tex_coords( const SGBucket& b, const point_list& geod_nodes,
+point_list sgCalcTexCoords( const SGBucket& b, const point_list& geod_nodes,
 			    const int_list& fan, double scale )
 {
     // cout << "calculating texture coordinates for a specific fan of size = "

simgear/misc/texcoord.hxx

@@ -47,7 +47,7 @@
  * @param scale (default = 1.0) scaling factor
  * @return list of texture coordinates
  */
-point_list calc_tex_coords( const SGBucket& b, const point_list& geod_nodes,
+point_list sgCalcTexCoords( const SGBucket& b, const point_list& geod_nodes,
 			    const int_list& fan, double scale = 1.0 );
 
 

simgear/misc/zfstream.hxx

@@ -32,12 +32,6 @@
 
 #include <zlib.h>
 
-// At least Irix needs this
-#ifdef SG_HAVE_NATIVE_SGI_COMPILERS
-#include <char_traits.h>
-SG_USING_STD(char_traits);
-#endif
-
 #ifdef SG_HAVE_STD_INCLUDES
 
 #  include <streambuf>
@@ -76,8 +70,6 @@ SG_USING_STD(streamoff);
 
 #if defined(__GNUC__) && __GNUC_MINOR__ < 8
 #  define ios_binary   ios::bin
-#elif defined( SG_HAVE_NATIVE_SGI_COMPILERS )
-#  define ios_binary   0
 #else
 #  define ios_binary   ios::binary
 #endif
@@ -94,7 +86,11 @@ SG_USING_STD(streamoff);
 /**
  * A C++ I/O streams interface to the zlib gz* functions.
  */
+#ifdef SG_NEED_STREAMBUF_HACK
+class gzfilebuf : public __streambuf
+#else
 class gzfilebuf : public streambuf
+#endif
 {
 public:
 

simgear/props/.cvsignore

@@ -0,0 +1,4 @@
+.deps
+Makefile
+Makefile.in
+props_test

simgear/props/Makefile.am

@@ -0,0 +1,25 @@
+includedir = @includedir@/props
+
+lib_LIBRARIES = libsgprops.a
+
+include_HEADERS = \
+	condition.hxx \
+	props.hxx \
+	props_io.hxx
+
+libsgprops_a_SOURCES = \
+	condition.cxx \
+	props.cxx \
+	props_io.cxx
+
+noinst_PROGRAMS = props_test
+
+props_test_SOURCES = props_test.cxx
+props_test_LDADD = \
+	$(top_builddir)/simgear/props/libsgprops.a \
+	$(top_builddir)/simgear/xml/libsgxml.a \
+	$(top_builddir)/simgear/misc/libsgmisc.a \
+	$(top_builddir)/simgear/debug/libsgdebug.a \
+	$(top_builddir)/simgear/structure/libsgstructure.a
+
+INCLUDES = -I$(top_srcdir)

simgear/props/condition.cxx

@@ -0,0 +1,430 @@
+// condition.cxx - Declarations and inline methods for property conditions.
+//
+// Written by David Megginson, started 2000.
+// CLO May 2003 - Split out condition specific code.
+//
+// This file is in the Public Domain, and comes with no warranty.
+//
+// $Id$
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear/compiler.h>
+#endif
+
+// #include STL_IOSTREAM
+
+#include <simgear/structure/exception.hxx>
+
+#include "props.hxx"
+#include "condition.hxx"
+
+SG_USING_STD(istream);
+SG_USING_STD(ostream);
+
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGCondition.
+////////////////////////////////////////////////////////////////////////
+
+SGCondition::SGCondition ()
+{
+}
+
+SGCondition::~SGCondition ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGPropertyCondition.
+////////////////////////////////////////////////////////////////////////
+
+SGPropertyCondition::SGPropertyCondition ( SGPropertyNode *prop_root,
+                                           const char *propname )
+    : _node( prop_root->getNode(propname, true) )
+{
+}
+
+SGPropertyCondition::~SGPropertyCondition ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGNotCondition.
+////////////////////////////////////////////////////////////////////////
+
+SGNotCondition::SGNotCondition (SGCondition * condition)
+  : _condition(condition)
+{
+}
+
+SGNotCondition::~SGNotCondition ()
+{
+  delete _condition;
+}
+
+bool
+SGNotCondition::test () const
+{
+  return !(_condition->test());
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGAndCondition.
+////////////////////////////////////////////////////////////////////////
+
+SGAndCondition::SGAndCondition ()
+{
+}
+
+SGAndCondition::~SGAndCondition ()
+{
+  for (unsigned int i = 0; i < _conditions.size(); i++)
+    delete _conditions[i];
+}
+
+bool
+SGAndCondition::test () const
+{
+  int nConditions = _conditions.size();
+  for (int i = 0; i < nConditions; i++) {
+    if (!_conditions[i]->test())
+      return false;
+  }
+  return true;
+}
+
+void
+SGAndCondition::addCondition (SGCondition * condition)
+{
+  _conditions.push_back(condition);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGOrCondition.
+////////////////////////////////////////////////////////////////////////
+
+SGOrCondition::SGOrCondition ()
+{
+}
+
+SGOrCondition::~SGOrCondition ()
+{
+  for (unsigned int i = 0; i < _conditions.size(); i++)
+    delete _conditions[i];
+}
+
+bool
+SGOrCondition::test () const
+{
+  int nConditions = _conditions.size();
+  for (int i = 0; i < nConditions; i++) {
+    if (_conditions[i]->test())
+      return true;
+  }
+  return false;
+}
+
+void
+SGOrCondition::addCondition (SGCondition * condition)
+{
+  _conditions.push_back(condition);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGComparisonCondition.
+////////////////////////////////////////////////////////////////////////
+
+static int
+doComparison (const SGPropertyNode * left, const SGPropertyNode *right)
+{
+  switch (left->getType()) {
+  case SGPropertyNode::BOOL: {
+    bool v1 = left->getBoolValue();
+    bool v2 = right->getBoolValue();
+    if (v1 < v2)
+      return SGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return SGComparisonCondition::GREATER_THAN;
+    else
+      return SGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::INT: {
+    int v1 = left->getIntValue();
+    int v2 = right->getIntValue();
+    if (v1 < v2)
+      return SGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return SGComparisonCondition::GREATER_THAN;
+    else
+      return SGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::LONG: {
+    long v1 = left->getLongValue();
+    long v2 = right->getLongValue();
+    if (v1 < v2)
+      return SGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return SGComparisonCondition::GREATER_THAN;
+    else
+      return SGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::FLOAT: {
+    float v1 = left->getFloatValue();
+    float v2 = right->getFloatValue();
+    if (v1 < v2)
+      return SGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return SGComparisonCondition::GREATER_THAN;
+    else
+      return SGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::DOUBLE: {
+    double v1 = left->getDoubleValue();
+    double v2 = right->getDoubleValue();
+    if (v1 < v2)
+      return SGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return SGComparisonCondition::GREATER_THAN;
+    else
+      return SGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::STRING: 
+  case SGPropertyNode::NONE:
+  case SGPropertyNode::UNSPECIFIED: {
+    string v1 = left->getStringValue();
+    string v2 = right->getStringValue();
+    if (v1 < v2)
+      return SGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return SGComparisonCondition::GREATER_THAN;
+    else
+      return SGComparisonCondition::EQUALS;
+    break;
+  }
+  }
+  throw sg_exception("Unrecognized node type");
+  return 0;
+}
+
+
+SGComparisonCondition::SGComparisonCondition (Type type, bool reverse)
+  : _type(type),
+    _reverse(reverse),
+    _left_property(0),
+    _right_property(0),
+    _right_value(0)
+{
+}
+
+SGComparisonCondition::~SGComparisonCondition ()
+{
+  delete _right_value;
+}
+
+bool
+SGComparisonCondition::test () const
+{
+				// Always fail if incompletely specified
+  if (_left_property == 0 ||
+      (_right_property == 0 && _right_value == 0))
+    return false;
+
+				// Get LESS_THAN, EQUALS, or GREATER_THAN
+  int cmp =
+    doComparison(_left_property,
+		 (_right_property != 0 ? _right_property : _right_value));
+  if (!_reverse)
+    return (cmp == _type);
+  else
+    return (cmp != _type);
+}
+
+void
+SGComparisonCondition::setLeftProperty( SGPropertyNode *prop_root,
+                                        const char * propname )
+{
+  _left_property = prop_root->getNode(propname, true);
+}
+
+void
+SGComparisonCondition::setRightProperty( SGPropertyNode *prop_root,
+                                         const char * propname )
+{
+  delete _right_value;
+  _right_value = 0;
+  _right_property = prop_root->getNode(propname, true);
+}
+
+void
+SGComparisonCondition::setRightValue (const SGPropertyNode *node)
+{
+  _right_property = 0;
+  delete _right_value;
+  _right_value = new SGPropertyNode(*node);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Read a condition and use it if necessary.
+////////////////////////////////////////////////////////////////////////
+
+                                // Forward declaration
+static SGCondition * readCondition( SGPropertyNode *prop_root,
+                                    const SGPropertyNode *node );
+
+static SGCondition *
+readPropertyCondition( SGPropertyNode *prop_root,
+                       const SGPropertyNode *node )
+{
+  return new SGPropertyCondition( prop_root, node->getStringValue() );
+}
+
+static SGCondition *
+readNotCondition( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  int nChildren = node->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * child = node->getChild(i);
+    SGCondition * condition = readCondition(prop_root, child);
+    if (condition != 0)
+      return new SGNotCondition(condition);
+  }
+  SG_LOG(SG_COCKPIT, SG_ALERT, "Panel: empty 'not' condition");
+  return 0;
+}
+
+static SGCondition *
+readAndConditions( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  SGAndCondition * andCondition = new SGAndCondition;
+  int nChildren = node->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * child = node->getChild(i);
+    SGCondition * condition = readCondition(prop_root, child);
+    if (condition != 0)
+      andCondition->addCondition(condition);
+  }
+  return andCondition;
+}
+
+static SGCondition *
+readOrConditions( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  SGOrCondition * orCondition = new SGOrCondition;
+  int nChildren = node->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * child = node->getChild(i);
+    SGCondition * condition = readCondition(prop_root, child);
+    if (condition != 0)
+      orCondition->addCondition(condition);
+  }
+  return orCondition;
+}
+
+static SGCondition *
+readComparison( SGPropertyNode *prop_root,
+                const SGPropertyNode *node,
+                SGComparisonCondition::Type type,
+		bool reverse)
+{
+  SGComparisonCondition * condition = new SGComparisonCondition(type, reverse);
+  condition->setLeftProperty(prop_root, node->getStringValue("property[0]"));
+  if (node->hasValue("property[1]"))
+    condition->setRightProperty(prop_root, node->getStringValue("property[1]"));
+  else
+    condition->setRightValue(node->getChild("value", 0));
+
+  return condition;
+}
+
+static SGCondition *
+readCondition( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  const string &name = node->getName();
+  if (name == "property")
+    return readPropertyCondition(prop_root, node);
+  else if (name == "not")
+    return readNotCondition(prop_root, node);
+  else if (name == "and")
+    return readAndConditions(prop_root, node);
+  else if (name == "or")
+    return readOrConditions(prop_root, node);
+  else if (name == "less-than")
+    return readComparison(prop_root, node, SGComparisonCondition::LESS_THAN,
+                          false);
+  else if (name == "less-than-equals")
+    return readComparison(prop_root, node, SGComparisonCondition::GREATER_THAN,
+                          true);
+  else if (name == "greater-than")
+    return readComparison(prop_root, node, SGComparisonCondition::GREATER_THAN,
+                          false);
+  else if (name == "greater-than-equals")
+    return readComparison(prop_root, node, SGComparisonCondition::LESS_THAN,
+                          true);
+  else if (name == "equals")
+    return readComparison(prop_root, node, SGComparisonCondition::EQUALS,
+                          false);
+  else if (name == "not-equals")
+    return readComparison(prop_root, node, SGComparisonCondition::EQUALS, true);
+  else
+    return 0;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGConditional.
+////////////////////////////////////////////////////////////////////////
+
+SGConditional::SGConditional ()
+  : _condition (0)
+{
+}
+
+SGConditional::~SGConditional ()
+{
+  delete _condition;
+}
+
+void
+SGConditional::setCondition (SGCondition * condition)
+{
+  delete _condition;
+  _condition = condition;
+}
+
+bool
+SGConditional::test () const
+{
+  return ((_condition == 0) || _condition->test());
+}
+
+
+
+// The top-level is always an implicit 'and' group
+SGCondition *
+sgReadCondition( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  return readAndConditions(prop_root, node);
+}
+
+
+// end of condition.cxx

simgear/props/condition.hxx

@@ -0,0 +1,179 @@
+/**
+ * \file condition.hxx
+ * Declarations and inline methods for property conditions.
+ * Written by David Megginson, started 2000.
+ * CLO May 2003 - Split out condition specific code.
+ *
+ * This file is in the Public Domain, and comes with no warranty.
+ */
+
+#ifndef __SG_CONDITION_HXX
+#define __SG_CONDITION_HXX
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/props/props.hxx>
+#include <simgear/props/props_io.hxx>
+
+
+////////////////////////////////////////////////////////////////////////
+// Conditions.
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * An encoded condition.
+ *
+ * This class encodes a single condition of some sort, possibly
+ * connected with properties.
+ *
+ * This class should migrate to somewhere more general.
+ */
+class SGCondition
+{
+public:
+  SGCondition ();
+  virtual ~SGCondition ();
+  virtual bool test () const = 0;
+};
+
+
+/**
+ * Condition for a single property.
+ *
+ * This condition is true only if the property returns a boolean
+ * true value.
+ */
+class SGPropertyCondition : public SGCondition
+{
+public:
+  SGPropertyCondition ( SGPropertyNode *prop_root,
+                        const char * propname  );
+  virtual ~SGPropertyCondition ();
+  virtual bool test () const { return _node->getBoolValue(); }
+private:
+  const SGPropertyNode * _node;
+};
+
+
+/**
+ * Condition for a 'not' operator.
+ *
+ * This condition is true only if the child condition is false.
+ */
+class SGNotCondition : public SGCondition
+{
+public:
+				// transfer pointer ownership
+  SGNotCondition (SGCondition * condition);
+  virtual ~SGNotCondition ();
+  virtual bool test () const;
+private:
+  SGCondition * _condition;
+};
+
+
+/**
+ * Condition for an 'and' group.
+ *
+ * This condition is true only if all of the conditions
+ * in the group are true.
+ */
+class SGAndCondition : public SGCondition
+{
+public:
+  SGAndCondition ();
+  virtual ~SGAndCondition ();
+  virtual bool test () const;
+				// transfer pointer ownership
+  virtual void addCondition (SGCondition * condition);
+private:
+  vector<SGCondition *> _conditions;
+};
+
+
+/**
+ * Condition for an 'or' group.
+ *
+ * This condition is true if at least one of the conditions in the
+ * group is true.
+ */
+class SGOrCondition : public SGCondition
+{
+public:
+  SGOrCondition ();
+  virtual ~SGOrCondition ();
+  virtual bool test () const;
+				// transfer pointer ownership
+  virtual void addCondition (SGCondition * condition);
+private:
+  vector<SGCondition *> _conditions;
+};
+
+
+/**
+ * Abstract base class for property comparison conditions.
+ */
+class SGComparisonCondition : public SGCondition
+{
+public:
+  enum Type {
+    LESS_THAN,
+    GREATER_THAN,
+    EQUALS
+  };
+  SGComparisonCondition (Type type, bool reverse = false);
+  virtual ~SGComparisonCondition ();
+  virtual bool test () const;
+  virtual void setLeftProperty( SGPropertyNode *prop_root,
+                                const char * propname );
+  virtual void setRightProperty( SGPropertyNode *prop_root,
+                                 const char * propname );
+				// will make a local copy
+  virtual void setRightValue (const SGPropertyNode * value);
+private:
+  Type _type;
+  bool _reverse;
+  const SGPropertyNode * _left_property;
+  const SGPropertyNode * _right_property;
+  const SGPropertyNode * _right_value;
+};
+
+
+/**
+ * Base class for a conditional components.
+ *
+ * This class manages the conditions and tests; the component should
+ * invoke the test() method whenever it needs to decide whether to
+ * active itself, draw itself, and so on.
+ */
+class SGConditional
+{
+public:
+  SGConditional ();
+  virtual ~SGConditional ();
+				// transfer pointer ownership
+  virtual void setCondition (SGCondition * condition);
+  virtual const SGCondition * getCondition () const { return _condition; }
+  virtual bool test () const;
+private:
+  SGCondition * _condition;
+};
+
+
+/**
+ * Global function to make a condition out of properties.
+ *
+ * The top-level is always an implicit 'and' group, whatever the
+ * node's name (it should usually be "condition").
+ *
+ * @param node The top-level condition node (usually named "condition").
+ * @return A pointer to a newly-allocated condition; it is the
+ *         responsibility of the caller to delete the condition when
+ *         it is no longer needed.
+ */
+SGCondition *sgReadCondition( SGPropertyNode *prop_root,
+                              const SGPropertyNode *node );
+
+
+#endif // __SG_CONDITION_HXX
+

simgear/props/props.cxx

@@ -113,7 +113,7 @@ parse_name (const string &path, int &i)
       name = ".";
     }
     if (i < max && path[i] != '/')
-      throw string(string("Illegal character after ") + name);
+      throw string("Illegal character after " + name);
   }
 
   else if (isalpha(path[i]) || path[i] == '_') {
@@ -1726,7 +1726,7 @@ SGPropertyNode::getNode (const char * relative_path, bool create)
     if (result != 0)
       _path_cache->put(relative_path, result);
   }
-  
+
   return result;
 }
 

simgear/props/props.hxx

@@ -36,10 +36,8 @@ using std::ostream;
 #include STL_IOSTREAM
 SG_USING_STD(string);
 SG_USING_STD(vector);
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(istream);
 SG_USING_STD(ostream);
-#endif
 
 #endif
 

simgear/props/props_io.cxx

@@ -5,28 +5,22 @@
 
 #include <simgear/sg_inlines.h>
 #include <simgear/debug/logstream.hxx>
+#include <simgear/misc/sg_path.hxx>
 #include <simgear/xml/easyxml.hxx>
 
-#include "sg_path.hxx"
 #include "props.hxx"
 #include "props_io.hxx"
 
 #include STL_IOSTREAM
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
-#  include <fstream>
-#else
-#  include <fstream.h>
-#endif
+#include STL_FSTREAM
 #include STL_STRING
 #include <vector>
 #include <map>
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(istream);
 SG_USING_STD(ifstream);
 SG_USING_STD(ostream);
 SG_USING_STD(ofstream);
-#endif
 SG_USING_STD(string);
 SG_USING_STD(vector);
 SG_USING_STD(map);
@@ -123,9 +117,9 @@ checkFlag (const char * flag, bool defaultState = true)
 {
   if (flag == 0)
     return defaultState;
-  else if (string(flag) == "y")
+  else if (!strcmp(flag, "y"))
     return true;
-  else if (string(flag) == "n")
+  else if (!strcmp(flag, "n"))
     return false;
   else {
     string message = "Unrecognized flag value '";
@@ -143,7 +137,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
   const char * attval;
 
   if (_level == 0) {
-    if (string(name) != (string)"PropertyList") {
+    if (strcmp(name, "PropertyList")) {
       string message = "Root element name is ";
       message += name;
       message += "; expected PropertyList";

simgear/props/props_io.hxx

@@ -13,7 +13,7 @@
 #define __PROPS_IO_HXX
 
 #include <simgear/compiler.h>
-#include <simgear/misc/props.hxx>
+#include <simgear/props/props.hxx>
 
 #include <stdio.h>
 
@@ -25,10 +25,8 @@
 SG_USING_STD(string);
 SG_USING_STD(vector);
 SG_USING_STD(map);
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(istream);
 SG_USING_STD(ostream);
-#endif
 
 /**
  * Read properties from an XML input stream.

simgear/props/props_test.cxx

@@ -9,11 +9,9 @@
 #include "props.hxx"
 #include "props_io.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(cout);
 SG_USING_STD(cerr);
 SG_USING_STD(endl);
-#endif
 
 
 

simgear/route/Makefile.am

@@ -19,7 +19,7 @@ waytest_LDADD = \
 	$(top_builddir)/simgear/math/libsgmath.a \
 	$(top_builddir)/simgear/debug/libsgdebug.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
-	$(top_builddir)/simgear/xml/libsgxml.a \
+	$(base_LIBS) \
 	-lz
 
 routetest_SOURCES = routetest.cxx
@@ -27,4 +27,5 @@ routetest_SOURCES = routetest.cxx
 routetest_LDADD = \
 	$(top_builddir)/simgear/route/libsgroute.a \
 	$(top_builddir)/simgear/math/libsgmath.a \
-	$(top_builddir)/simgear/debug/libsgdebug.a
+	$(top_builddir)/simgear/debug/libsgdebug.a \
+	$(base_LIBS)

simgear/route/routetest.cxx

@@ -6,10 +6,8 @@
 #include "route.hxx"
 #include "waypoint.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(cout);
 SG_USING_STD(endl);
-#endif
  
 int main() {
     SGRoute route;

simgear/route/waytest.cxx

@@ -5,11 +5,8 @@
 
 #include "waypoint.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(cout);
 SG_USING_STD(endl);
-#endif
-
 
 int main() {
     SGWayPoint a1(-93.216923, 44.880547, 0.0, SGWayPoint::WGS84, "KMSP");

simgear/scene/.cvsignore

@@ -0,0 +1,3 @@
+.deps
+Makefile
+Makefile.in

simgear/scene/Makefile.am

@@ -0,0 +1,13 @@
+includedir = @includedir@/scene
+
+SUBDIRS = material model sky tgdb
+
+# lib_LIBRARIES = libsgscene.a
+
+# noinst_HEADERS =
+
+# include_HEADERS =
+
+# libsgscene_a_SOURCES =
+
+INCLUDES = -I$(top_srcdir)

simgear/scene/material/.cvsignore

@@ -0,0 +1,3 @@
+.deps
+Makefile
+Makefile.in

simgear/scene/material/Makefile.am

@@ -0,0 +1,17 @@
+includedir = @includedir@/scene/material
+
+lib_LIBRARIES = libsgmaterial.a
+
+noinst_HEADERS =
+
+include_HEADERS = \
+	mat.hxx \
+	matlib.hxx \
+	matmodel.hxx
+
+libsgmaterial_a_SOURCES = \
+	mat.cxx \
+	matlib.cxx \
+	matmodel.cxx
+
+INCLUDES = -I$(top_srcdir)

simgear/scene/material/mat.cxx

@@ -0,0 +1,248 @@
+// mat.cxx -- class to handle material properties
+//
+// Written by Curtis Olson, started May 1998.
+//
+// Copyright (C) 1998 - 2000  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$
+
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include <map>
+SG_USING_STD(map);
+
+#include <simgear/compiler.h>
+
+#ifdef SG_MATH_EXCEPTION_CLASH
+#  include <math.h>
+#endif
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/math/sg_random.h>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/sgstream.hxx>
+
+#include "mat.hxx"
+
+
+////////////////////////////////////////////////////////////////////////
+// Local static functions.
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Internal method to test whether a file exists.
+ *
+ * TODO: this should be moved to a SimGear library of local file
+ * functions.
+ */
+static inline bool
+local_file_exists( const string& path ) {
+    sg_gzifstream in( path );
+    if ( ! in.is_open() ) {
+	return false;
+    } else {
+	return true;
+    }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Constructors and destructor.
+////////////////////////////////////////////////////////////////////////
+
+
+SGMaterial::SGMaterial( const string &fg_root, const SGPropertyNode *props )
+{
+    init();
+    read_properties( fg_root, props );
+    build_ssg_state( false );
+}
+
+SGMaterial::SGMaterial( const string &texpath )
+{
+    init();
+    texture_path = texpath;
+    build_ssg_state( true );
+}
+
+SGMaterial::SGMaterial( ssgSimpleState *s )
+{
+    init();
+    set_ssg_state( s );
+}
+
+SGMaterial::~SGMaterial (void)
+{
+  for (unsigned int i = 0; i < object_groups.size(); i++) {
+    delete object_groups[i];
+    object_groups[i] = 0;
+  }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Public methods.
+////////////////////////////////////////////////////////////////////////
+
+void
+SGMaterial::read_properties( const string &fg_root, const SGPropertyNode * props )
+{
+				// Get the path to the texture
+  string tname = props->getStringValue("texture", "unknown.rgb");
+  SGPath tpath( fg_root );
+  tpath.append("Textures.high");
+  tpath.append(tname);
+  if (!local_file_exists(tpath.str())) {
+    tpath = SGPath( fg_root );
+    tpath.append("Textures");
+    tpath.append(tname);
+  }
+  texture_path = tpath.str();
+
+  xsize = props->getDoubleValue("xsize", 0.0);
+  ysize = props->getDoubleValue("ysize", 0.0);
+  wrapu = props->getBoolValue("wrapu", true);
+  wrapv = props->getBoolValue("wrapv", true);
+  mipmap = props->getBoolValue("mipmap", true);
+  light_coverage = props->getDoubleValue("light-coverage", 0.0);
+
+  // Taken from default values as used in ac3d
+  ambient[0] = props->getDoubleValue("ambient/r", 0.2);
+  ambient[1] = props->getDoubleValue("ambient/g", 0.2);
+  ambient[2] = props->getDoubleValue("ambient/b", 0.2);
+  ambient[3] = props->getDoubleValue("ambient/a", 1.0);
+
+  diffuse[0] = props->getDoubleValue("diffuse/r", 0.8);
+  diffuse[1] = props->getDoubleValue("diffuse/g", 0.8);
+  diffuse[2] = props->getDoubleValue("diffuse/b", 0.8);
+  diffuse[3] = props->getDoubleValue("diffuse/a", 1.0);
+
+  specular[0] = props->getDoubleValue("specular/r", 0.0);
+  specular[1] = props->getDoubleValue("specular/g", 0.0);
+  specular[2] = props->getDoubleValue("specular/b", 0.0);
+  specular[3] = props->getDoubleValue("specular/a", 1.0);
+
+  emission[0] = props->getDoubleValue("emissive/r", 0.0);
+  emission[1] = props->getDoubleValue("emissive/g", 0.0);
+  emission[2] = props->getDoubleValue("emissive/b", 0.0);
+  emission[3] = props->getDoubleValue("emissive/a", 1.0);
+
+  shininess = props->getDoubleValue("shininess", 1.0);
+
+  vector<SGPropertyNode_ptr> object_group_nodes =
+    ((SGPropertyNode *)props)->getChildren("object-group");
+  for (unsigned int i = 0; i < object_group_nodes.size(); i++)
+    object_groups.push_back(new SGMatModelGroup(object_group_nodes[i]));
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Private methods.
+////////////////////////////////////////////////////////////////////////
+
+void 
+SGMaterial::init ()
+{
+    texture_path = "";
+    state = NULL;
+    xsize = 0;
+    ysize = 0;
+    wrapu = true;
+    wrapv = true;
+    mipmap = true;
+    light_coverage = 0.0;
+    texture_loaded = false;
+    refcount = 0;
+    shininess = 1.0;
+    for (int i = 0; i < 4; i++) {
+        ambient[i]  = (i < 3) ? 0.2 : 1.0;
+        specular[i] = (i < 3) ? 0.0 : 1.0;
+        diffuse[i]  = (i < 3) ? 0.8 : 1.0;
+        emission[i] = (i < 3) ? 0.0 : 1.0;
+    }
+}
+
+bool
+SGMaterial::load_texture ()
+{
+    if ( texture_loaded ) {
+        return false;
+    } else {
+        SG_LOG( SG_GENERAL, SG_INFO, "Loading deferred texture "
+                << texture_path );
+        state->setTexture( (char *)texture_path.c_str(), wrapu, wrapv, mipmap );
+        texture_loaded = true;
+        return true;
+    }
+}
+
+
+void 
+SGMaterial::build_ssg_state( bool defer_tex_load )
+{
+    GLenum shade_model = GL_SMOOTH;
+    
+    state = new ssgSimpleState();
+    state->ref();
+
+    // Set up the textured state
+    state->setShadeModel( shade_model );
+    state->enable( GL_LIGHTING );
+    state->enable ( GL_CULL_FACE ) ;
+    state->enable( GL_TEXTURE_2D );
+    state->disable( GL_BLEND );
+    state->disable( GL_ALPHA_TEST );
+    if ( !defer_tex_load ) {
+        SG_LOG(SG_INPUT, SG_INFO, "    " << texture_path );
+	state->setTexture( (char *)texture_path.c_str(), wrapu, wrapv );
+	texture_loaded = true;
+    } else {
+	texture_loaded = false;
+    }
+    state->enable( GL_COLOR_MATERIAL );
+    state->setMaterial ( GL_AMBIENT,
+                            ambient[0], ambient[1],
+                            ambient[2], ambient[3] ) ;
+    state->setMaterial ( GL_DIFFUSE,
+                            diffuse[0], diffuse[1],
+                            diffuse[2], diffuse[3] ) ;
+    state->setMaterial ( GL_SPECULAR,
+                            specular[0], specular[1],
+                            specular[2], specular[3] ) ;
+    state->setMaterial ( GL_EMISSION,
+                            emission[0], emission[1],
+                            emission[2], emission[3] ) ;
+    state->setShininess ( shininess );
+}
+
+
+void SGMaterial::set_ssg_state( ssgSimpleState *s )
+{
+    state = s;
+    state->ref();
+    texture_loaded = true;
+}
+
+// end of mat.cxx

simgear/scene/material/mat.hxx

@@ -0,0 +1,247 @@
+// mat.hxx -- a material in the scene graph.
+// TODO: this class needs to be renamed.
+//
+// Written by Curtis Olson, started May 1998.
+// Overhauled by David Megginson, December 2001
+//
+// Copyright (C) 1998 - 2000  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$
+
+
+#ifndef _SG_MAT_HXX
+#define _SG_MAT_HXX
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include <simgear/compiler.h>
+
+#include STL_STRING      // Standard C++ string library
+#include <vector>
+
+#include <plib/sg.h>
+#include <plib/ssg.h>
+
+#include <simgear/props/props.hxx>
+
+#include "matmodel.hxx"
+
+SG_USING_STD(string);
+SG_USING_STD(vector);
+
+
+/**
+ * A material in the scene graph.
+ *
+ * A material represents information about a single surface type
+ * in the 3D scene graph, including texture, colour, lighting,
+ * tiling, and so on; most of the materials in FlightGear are
+ * defined in the $FG_ROOT/materials.xml file, and can be changed
+ * at runtime.
+ */
+class SGMaterial {
+
+public:
+
+
+  ////////////////////////////////////////////////////////////////////
+  // Public Constructors.
+  ////////////////////////////////////////////////////////////////////
+
+  /**
+   * Construct a material from a set of properties.
+   *
+   * @param props A property node containing subnodes with the
+   * state information for the material.  This node is usually
+   * loaded from the $FG_ROOT/materials.xml file.
+   */
+  SGMaterial( const string &fg_root, const SGPropertyNode *props );
+
+
+  /**
+   * Construct a material from an absolute texture path.
+   *
+   * @param texture_path A string containing an absolute path
+   * to a texture file (usually RGB).
+   */
+  SGMaterial( const string &texpath );
+
+
+  /**
+   * Construct a material around an existing SSG state.
+   *
+   * This constructor allows the application to create a custom,
+   * low-level state for the scene graph and wrap a material around
+   * it.  Note: the pointer ownership is transferred to the material.
+   *
+   * @param s The SSG state for this material.
+   */
+  SGMaterial( ssgSimpleState *s );
+
+  /**
+   * Destructor.
+   */
+  virtual ~SGMaterial( void );
+
+
+
+  ////////////////////////////////////////////////////////////////////
+  // Public methods.
+  ////////////////////////////////////////////////////////////////////
+
+  /**
+   * Force the texture to load if it hasn't already.
+   *
+   * @return true if the texture loaded, false if it was loaded
+   * already.
+   */
+  virtual bool load_texture ();
+
+
+  /**
+   * Get the textured state.
+   */
+  virtual inline ssgSimpleState *get_state () const { return state; }
+
+
+  /**
+   * Get the xsize of the texture, in meters.
+   */
+  virtual inline double get_xsize() const { return xsize; }
+
+
+  /**
+   * Get the ysize of the texture, in meters.
+   */
+  virtual inline double get_ysize() const { return ysize; }
+
+
+  /**
+   * Get the light coverage.
+   *
+   * A smaller number means more generated night lighting.
+   *
+   * @return The area (m^2?) covered by each light.
+   */
+  virtual inline double get_light_coverage () const { return light_coverage; }
+
+
+  /**
+   * Get the number of randomly-placed objects defined for this material.
+   */
+  virtual int get_object_group_count () const { return object_groups.size(); }
+
+
+  /**
+   * Get a randomly-placed object for this material.
+   */
+  virtual SGMatModelGroup * get_object_group (int index) const {
+    return object_groups[index];
+  }
+
+
+  /**
+   * Increment the reference count for this material.
+   *
+   * A material with 0 references may be deleted by the
+   * material library.
+   */
+  virtual inline void ref () { refcount++; }
+
+
+  /**
+   * Decrement the reference count for this material.
+   */
+  virtual inline void deRef () { refcount--; }
+
+
+  /**
+   * Get the reference count for this material.
+   *
+   * @return The number of references (0 if none).
+   */
+  virtual inline int getRef () const { return refcount; }
+
+protected:
+
+
+  ////////////////////////////////////////////////////////////////////
+  // Protected methods.
+  ////////////////////////////////////////////////////////////////////
+
+  /**
+   * Initialization method, invoked by all public constructors.
+   */
+  virtual void init();
+
+
+private:
+
+
+  ////////////////////////////////////////////////////////////////////
+  // Internal state.
+  ////////////////////////////////////////////////////////////////////
+
+  // names
+  string texture_path;
+
+  // pointers to ssg states
+  ssgSimpleState *state;
+
+  // texture size
+  double xsize, ysize;
+
+  // wrap texture?
+  bool wrapu, wrapv;
+
+  // use mipmapping?
+  int mipmap;
+
+  // coverage of night lighting.
+  double light_coverage;
+
+  // material properties
+  sgVec4 ambient, diffuse, specular, emission;
+  double shininess;
+
+  // true if texture loading deferred, and not yet loaded
+  bool texture_loaded;
+
+  vector<SGMatModelGroup *> object_groups;
+
+  // ref count so we can properly delete if we have multiple
+  // pointers to this record
+  int refcount;
+
+
+
+  ////////////////////////////////////////////////////////////////////
+  // Internal constructors and methods.
+  ////////////////////////////////////////////////////////////////////
+
+  SGMaterial( const string &fg_root, const SGMaterial &mat ); // unimplemented
+
+  void read_properties( const string &fg_root, const SGPropertyNode *props );
+  void build_ssg_state( bool defer_tex_load );
+  void set_ssg_state( ssgSimpleState *s );
+
+
+};
+
+#endif // _SG_MAT_HXX 

simgear/scene/material/matlib.cxx

@@ -0,0 +1,613 @@
+// materialmgr.cxx -- class to handle material properties
+//
+// Written by Curtis Olson, started May 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$
+
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#ifdef SG_MATH_EXCEPTION_CLASH
+#  include <math.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include <GL/gl.h>
+
+#include <simgear/compiler.h>
+#include <simgear/constants.h>
+#include <simgear/structure/exception.hxx>
+
+#include <string.h>
+#include STL_STRING
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/sgstream.hxx>
+#include <simgear/props/props_io.hxx>
+
+#include "mat.hxx"
+
+#include "matlib.hxx"
+
+SG_USING_NAMESPACE(std);
+SG_USING_STD(string);
+
+
+// Constructor
+SGMaterialLib::SGMaterialLib ( void ) {
+}
+
+
+#if 0 // debugging infrastructure
+static int gen_test_light_map() {
+    static const int env_tex_res = 32;
+    int half_res = env_tex_res / 2;
+    unsigned char env_map[env_tex_res][env_tex_res][4];
+    GLuint tex_name;
+
+    for ( int i = 0; i < env_tex_res; ++i ) {
+        for ( int j = 0; j < env_tex_res; ++j ) {
+            double x = (i - half_res) / (double)half_res;
+            double y = (j - half_res) / (double)half_res;
+            double dist = sqrt(x*x + y*y);
+            if ( dist > 1.0 ) { dist = 1.0; }
+
+            // cout << x << "," << y << " " << (int)(dist * 255) << ","
+            //      << (int)((1.0 - dist) * 255) << endl;
+            env_map[i][j][0] = (int)(dist * 255);
+            env_map[i][j][1] = (int)((1.0 - dist) * 255);
+            env_map[i][j][2] = 0;
+            env_map[i][j][3] = 255;
+        }
+    }
+
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+    glGenTextures( 1, &tex_name );
+    glBindTexture( GL_TEXTURE_2D, tex_name );
+  
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, env_tex_res, env_tex_res, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, env_map);
+
+    return tex_name;
+}
+#endif
+
+
+// generate standard colored directional light environment texture map
+static int gen_standard_dir_light_map( int r, int g, int b, int alpha ) {
+    const int env_tex_res = 32;
+    int half_res = env_tex_res / 2;
+    unsigned char env_map[env_tex_res][env_tex_res][4];
+    GLuint tex_name;
+
+    for ( int i = 0; i < env_tex_res; ++i ) {
+        for ( int j = 0; j < env_tex_res; ++j ) {
+            double x = (i - half_res) / (double)half_res;
+            double y = (j - half_res) / (double)half_res;
+            double dist = sqrt(x*x + y*y);
+            if ( dist > 1.0 ) { dist = 1.0; }
+            double bright = cos( dist * SGD_PI_2 );
+            if ( bright < 0.3 ) { bright = 0.3; }
+            env_map[i][j][0] = r;
+            env_map[i][j][1] = g;
+            env_map[i][j][2] = b;
+            env_map[i][j][3] = (int)(bright * alpha);
+        }
+    }
+
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+    glGenTextures( 1, &tex_name );
+    glBindTexture( GL_TEXTURE_2D, tex_name );
+  
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, env_tex_res, env_tex_res, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, env_map);
+
+    return tex_name;
+}
+
+
+// generate standard colored directional light environment texture map
+static int gen_taxiway_dir_light_map( int r, int g, int b, int alpha ) {
+    const int env_tex_res = 32;
+    int half_res = env_tex_res / 2;
+    unsigned char env_map[env_tex_res][env_tex_res][4];
+    GLuint tex_name;
+
+    for ( int i = 0; i < env_tex_res; ++i ) {
+        for ( int j = 0; j < env_tex_res; ++j ) {
+            double x = (i - half_res) / (double)half_res;
+            double y = (j - half_res) / (double)half_res;
+            double tmp = sqrt(x*x + y*y);
+            double dist = tmp * tmp;
+            if ( dist > 1.0 ) { dist = 1.0; }
+            double bright = sin( dist * SGD_PI_2 );
+            if ( bright < 0.2 ) { bright = 0.2; }
+            env_map[i][j][0] = r;
+            env_map[i][j][1] = g;
+            env_map[i][j][2] = b;
+            env_map[i][j][3] = (int)(bright * alpha);
+        }
+    }
+
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+    glGenTextures( 1, &tex_name );
+    glBindTexture( GL_TEXTURE_2D, tex_name );
+  
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, env_tex_res, env_tex_res, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, env_map);
+
+    return tex_name;
+}
+
+
+// generate the directional vasi light environment texture map
+static int gen_vasi_light_map() {
+    const int env_tex_res = 256;
+    int half_res = env_tex_res / 2;
+    unsigned char env_map[env_tex_res][env_tex_res][4];
+    GLuint tex_name;
+
+    for ( int i = 0; i < env_tex_res; ++i ) {
+        for ( int j = 0; j < env_tex_res; ++j ) {
+            double x = (i - half_res) / (double)half_res;
+            double y = (j - half_res) / (double)half_res;
+            double dist = sqrt(x*x + y*y);
+            if ( dist > 1.0 ) { dist = 1.0; }
+            double bright = cos( dist * SGD_PI_2 );
+
+            // top half white, bottom half red
+            env_map[i][j][0] = 255;
+            if ( i > half_res ) {
+                // white
+                env_map[i][j][1] = 255;
+                env_map[i][j][2] = 255;
+            } else if ( i == half_res - 1 || i == half_res ) {
+                // pink
+                env_map[i][j][1] = 127;
+                env_map[i][j][2] = 127;
+            } else {
+                // red
+                env_map[i][j][1] = 0;
+                env_map[i][j][2] = 0;
+            }
+            env_map[i][j][3] = (int)(bright * 255);
+        }
+    }
+
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+    glGenTextures( 1, &tex_name );
+    glBindTexture( GL_TEXTURE_2D, tex_name );
+  
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, env_tex_res, env_tex_res, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, env_map);
+
+    return tex_name;
+}
+
+
+// Load a library of material properties
+bool SGMaterialLib::load( const string &fg_root, const string& mpath ) {
+
+    SGPropertyNode materials;
+
+    SG_LOG( SG_INPUT, SG_INFO, "Reading materials from " << mpath );
+    try {
+        readProperties( mpath, &materials );
+    } catch (const sg_exception &ex) {
+        SG_LOG( SG_INPUT, SG_ALERT, "Error reading materials: "
+                << ex.getMessage() );
+        throw ex;
+    }
+
+    int nMaterials = materials.nChildren();
+    for (int i = 0; i < nMaterials; i++) {
+        const SGPropertyNode * node = materials.getChild(i);
+        if (!strcmp(node->getName(), "material")) {
+            SGMaterial *m = new SGMaterial( fg_root, node );
+
+            vector<SGPropertyNode_ptr>names = node->getChildren("name");
+            for ( unsigned int j = 0; j < names.size(); j++ ) {
+                string name = names[j]->getStringValue();
+                m->ref();
+                // cerr << "Material " << name << endl;
+                matlib[name] = m;
+                SG_LOG( SG_TERRAIN, SG_INFO, "  Loading material "
+                        << names[j]->getStringValue() );
+            }
+        } else {
+            SG_LOG(SG_INPUT, SG_ALERT,
+                   "Skipping bad material entry " << node->getName());
+        }
+    }
+
+    // hard coded ground light state
+    ssgSimpleState *gnd_lights = new ssgSimpleState;
+    gnd_lights->ref();
+    gnd_lights->disable( GL_TEXTURE_2D );
+    gnd_lights->enable( GL_CULL_FACE );
+    gnd_lights->enable( GL_COLOR_MATERIAL );
+    gnd_lights->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
+    gnd_lights->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
+    gnd_lights->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
+    gnd_lights->enable( GL_BLEND );
+    gnd_lights->disable( GL_ALPHA_TEST );
+    gnd_lights->disable( GL_LIGHTING );
+    matlib["GROUND_LIGHTS"] = new SGMaterial( gnd_lights );
+
+    GLuint tex_name;
+
+    // hard coded runway white light state
+    tex_name = gen_standard_dir_light_map( 235, 235, 195, 255 );
+    ssgSimpleState *rwy_white_lights = new ssgSimpleState();
+    rwy_white_lights->ref();
+    rwy_white_lights->disable( GL_LIGHTING );
+    rwy_white_lights->enable ( GL_CULL_FACE ) ;
+    rwy_white_lights->enable( GL_TEXTURE_2D );
+    rwy_white_lights->enable( GL_BLEND );
+    rwy_white_lights->enable( GL_ALPHA_TEST );
+    rwy_white_lights->enable( GL_COLOR_MATERIAL );
+    rwy_white_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_white_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_white_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_white_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_white_lights->setTexture( tex_name );
+    matlib["RWY_WHITE_LIGHTS"] = new SGMaterial( rwy_white_lights );
+    // For backwards compatibility ... remove someday
+    matlib["RUNWAY_LIGHTS"] = new SGMaterial( rwy_white_lights );
+    matlib["RWY_LIGHTS"] = new SGMaterial( rwy_white_lights );
+    // end of backwards compatitibilty
+
+    // hard coded runway medium intensity white light state
+    tex_name = gen_standard_dir_light_map( 235, 235, 195, 205 );
+    ssgSimpleState *rwy_white_medium_lights = new ssgSimpleState();
+    rwy_white_medium_lights->ref();
+    rwy_white_medium_lights->disable( GL_LIGHTING );
+    rwy_white_medium_lights->enable ( GL_CULL_FACE ) ;
+    rwy_white_medium_lights->enable( GL_TEXTURE_2D );
+    rwy_white_medium_lights->enable( GL_BLEND );
+    rwy_white_medium_lights->enable( GL_ALPHA_TEST );
+    rwy_white_medium_lights->enable( GL_COLOR_MATERIAL );
+    rwy_white_medium_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_white_medium_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_white_medium_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_white_medium_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_white_medium_lights->setTexture( tex_name );
+    matlib["RWY_WHITE_MEDIUM_LIGHTS"]
+        = new SGMaterial( rwy_white_medium_lights );
+
+    // hard coded runway low intensity white light state
+    tex_name = gen_standard_dir_light_map( 235, 235, 195, 155 );
+    ssgSimpleState *rwy_white_low_lights = new ssgSimpleState();
+    rwy_white_low_lights->ref();
+    rwy_white_low_lights->disable( GL_LIGHTING );
+    rwy_white_low_lights->enable ( GL_CULL_FACE ) ;
+    rwy_white_low_lights->enable( GL_TEXTURE_2D );
+    rwy_white_low_lights->enable( GL_BLEND );
+    rwy_white_low_lights->enable( GL_ALPHA_TEST );
+    rwy_white_low_lights->enable( GL_COLOR_MATERIAL );
+    rwy_white_low_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_white_low_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_white_low_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_white_low_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_white_low_lights->setTexture( tex_name );
+    matlib["RWY_WHITE_LOW_LIGHTS"]
+        = new SGMaterial( rwy_white_low_lights );
+
+    // hard coded runway yellow light state
+    tex_name = gen_standard_dir_light_map( 235, 215, 20, 255 );
+    ssgSimpleState *rwy_yellow_lights = new ssgSimpleState();
+    rwy_yellow_lights->ref();
+    rwy_yellow_lights->disable( GL_LIGHTING );
+    rwy_yellow_lights->enable ( GL_CULL_FACE ) ;
+    rwy_yellow_lights->enable( GL_TEXTURE_2D );
+    rwy_yellow_lights->enable( GL_BLEND );
+    rwy_yellow_lights->enable( GL_ALPHA_TEST );
+    rwy_yellow_lights->enable( GL_COLOR_MATERIAL );
+    rwy_yellow_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_yellow_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_yellow_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_yellow_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_yellow_lights->setTexture( tex_name );
+    matlib["RWY_YELLOW_LIGHTS"] = new SGMaterial( rwy_yellow_lights );
+
+    // hard coded runway medium intensity yellow light state
+    tex_name = gen_standard_dir_light_map( 235, 215, 20, 205 );
+    ssgSimpleState *rwy_yellow_medium_lights = new ssgSimpleState();
+    rwy_yellow_medium_lights->ref();
+    rwy_yellow_medium_lights->disable( GL_LIGHTING );
+    rwy_yellow_medium_lights->enable ( GL_CULL_FACE ) ;
+    rwy_yellow_medium_lights->enable( GL_TEXTURE_2D );
+    rwy_yellow_medium_lights->enable( GL_BLEND );
+    rwy_yellow_medium_lights->enable( GL_ALPHA_TEST );
+    rwy_yellow_medium_lights->enable( GL_COLOR_MATERIAL );
+    rwy_yellow_medium_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_yellow_medium_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_yellow_medium_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_yellow_medium_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_yellow_medium_lights->setTexture( tex_name );
+    matlib["RWY_YELLOW_MEDIUM_LIGHTS"]
+        = new SGMaterial( rwy_yellow_medium_lights );
+
+    // hard coded runway low intensity yellow light state
+    tex_name = gen_standard_dir_light_map( 235, 215, 20, 155 );
+    ssgSimpleState *rwy_yellow_low_lights = new ssgSimpleState();
+    rwy_yellow_low_lights->ref();
+    rwy_yellow_low_lights->disable( GL_LIGHTING );
+    rwy_yellow_low_lights->enable ( GL_CULL_FACE ) ;
+    rwy_yellow_low_lights->enable( GL_TEXTURE_2D );
+    rwy_yellow_low_lights->enable( GL_BLEND );
+    rwy_yellow_low_lights->enable( GL_ALPHA_TEST );
+    rwy_yellow_low_lights->enable( GL_COLOR_MATERIAL );
+    rwy_yellow_low_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_yellow_low_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_yellow_low_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_yellow_low_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_yellow_low_lights->setTexture( tex_name );
+    matlib["RWY_YELLOW_LOW_LIGHTS"]
+        = new SGMaterial( rwy_yellow_low_lights );
+
+    // hard coded runway red light state
+    tex_name = gen_standard_dir_light_map( 235, 90, 90, 255 );
+    ssgSimpleState *rwy_red_lights = new ssgSimpleState();
+    rwy_red_lights->ref();
+    rwy_red_lights->disable( GL_LIGHTING );
+    rwy_red_lights->enable ( GL_CULL_FACE ) ;
+    rwy_red_lights->enable( GL_TEXTURE_2D );
+    rwy_red_lights->enable( GL_BLEND );
+    rwy_red_lights->enable( GL_ALPHA_TEST );
+    rwy_red_lights->enable( GL_COLOR_MATERIAL );
+    rwy_red_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_red_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_red_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_red_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_red_lights->setTexture( tex_name );
+    matlib["RWY_RED_LIGHTS"]
+        = new SGMaterial( rwy_red_lights );
+
+    // hard coded medium intensity runway red light state
+    tex_name = gen_standard_dir_light_map( 235, 90, 90, 205 );
+    ssgSimpleState *rwy_red_medium_lights = new ssgSimpleState();
+    rwy_red_medium_lights->ref();
+    rwy_red_medium_lights->disable( GL_LIGHTING );
+    rwy_red_medium_lights->enable ( GL_CULL_FACE ) ;
+    rwy_red_medium_lights->enable( GL_TEXTURE_2D );
+    rwy_red_medium_lights->enable( GL_BLEND );
+    rwy_red_medium_lights->enable( GL_ALPHA_TEST );
+    rwy_red_medium_lights->enable( GL_COLOR_MATERIAL );
+    rwy_red_medium_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_red_medium_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_red_medium_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_red_medium_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_red_medium_lights->setTexture( tex_name );
+    matlib["RWY_RED_MEDIUM_LIGHTS"]
+        = new SGMaterial( rwy_red_medium_lights );
+
+    // hard coded low intensity runway red light state
+    tex_name = gen_standard_dir_light_map( 235, 90, 90, 155 );
+    ssgSimpleState *rwy_red_low_lights = new ssgSimpleState();
+    rwy_red_low_lights->ref();
+    rwy_red_low_lights->disable( GL_LIGHTING );
+    rwy_red_low_lights->enable ( GL_CULL_FACE ) ;
+    rwy_red_low_lights->enable( GL_TEXTURE_2D );
+    rwy_red_low_lights->enable( GL_BLEND );
+    rwy_red_low_lights->enable( GL_ALPHA_TEST );
+    rwy_red_low_lights->enable( GL_COLOR_MATERIAL );
+    rwy_red_low_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_red_low_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_red_low_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_red_low_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_red_low_lights->setTexture( tex_name );
+    matlib["RWY_RED_LOW_LIGHTS"]
+        = new SGMaterial( rwy_red_low_lights );
+
+    // hard coded runway green light state
+    tex_name = gen_standard_dir_light_map( 20, 235, 20, 255 );
+    ssgSimpleState *rwy_green_lights = new ssgSimpleState();
+    rwy_green_lights->ref();
+    rwy_green_lights->disable( GL_LIGHTING );
+    rwy_green_lights->enable ( GL_CULL_FACE ) ;
+    rwy_green_lights->enable( GL_TEXTURE_2D );
+    rwy_green_lights->enable( GL_BLEND );
+    rwy_green_lights->enable( GL_ALPHA_TEST );
+    rwy_green_lights->enable( GL_COLOR_MATERIAL );
+    rwy_green_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_green_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_green_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_green_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_green_lights->setTexture( tex_name );
+    matlib["RWY_GREEN_LIGHTS"]
+        = new SGMaterial( rwy_green_lights );
+
+    // hard coded medium intensity runway green light state
+    tex_name = gen_standard_dir_light_map( 20, 235, 20, 205 );
+    ssgSimpleState *rwy_green_medium_lights = new ssgSimpleState();
+    rwy_green_medium_lights->ref();
+    rwy_green_medium_lights->disable( GL_LIGHTING );
+    rwy_green_medium_lights->enable ( GL_CULL_FACE ) ;
+    rwy_green_medium_lights->enable( GL_TEXTURE_2D );
+    rwy_green_medium_lights->enable( GL_BLEND );
+    rwy_green_medium_lights->enable( GL_ALPHA_TEST );
+    rwy_green_medium_lights->enable( GL_COLOR_MATERIAL );
+    rwy_green_medium_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_green_medium_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_green_medium_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_green_medium_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_green_medium_lights->setTexture( tex_name );
+    matlib["RWY_GREEN_MEDIUM_LIGHTS"]
+        = new SGMaterial( rwy_green_medium_lights );
+
+    // hard coded low intensity runway green light state
+    tex_name = gen_standard_dir_light_map( 20, 235, 20, 155 );
+    ssgSimpleState *rwy_green_low_lights = new ssgSimpleState();
+    rwy_green_low_lights->ref();
+    rwy_green_low_lights->disable( GL_LIGHTING );
+    rwy_green_low_lights->enable ( GL_CULL_FACE ) ;
+    rwy_green_low_lights->enable( GL_TEXTURE_2D );
+    rwy_green_low_lights->enable( GL_BLEND );
+    rwy_green_low_lights->enable( GL_ALPHA_TEST );
+    rwy_green_low_lights->enable( GL_COLOR_MATERIAL );
+    rwy_green_low_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_green_low_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_green_low_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_green_low_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_green_low_lights->setTexture( tex_name );
+    matlib["RWY_GREEN_LOW_LIGHTS"]
+        = new SGMaterial( rwy_green_low_lights );
+    matlib["RWY_GREEN_TAXIWAY_LIGHTS"]
+        = new SGMaterial( rwy_green_low_lights );
+
+    // hard coded low intensity taxiway blue light state
+    tex_name = gen_taxiway_dir_light_map( 90, 90, 235, 205 );
+    ssgSimpleState *taxiway_blue_low_lights = new ssgSimpleState();
+    taxiway_blue_low_lights->ref();
+    taxiway_blue_low_lights->disable( GL_LIGHTING );
+    taxiway_blue_low_lights->enable ( GL_CULL_FACE ) ;
+    taxiway_blue_low_lights->enable( GL_TEXTURE_2D );
+    taxiway_blue_low_lights->enable( GL_BLEND );
+    taxiway_blue_low_lights->enable( GL_ALPHA_TEST );
+    taxiway_blue_low_lights->enable( GL_COLOR_MATERIAL );
+    taxiway_blue_low_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    taxiway_blue_low_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    taxiway_blue_low_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    taxiway_blue_low_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    taxiway_blue_low_lights->setTexture( tex_name );
+    matlib["RWY_BLUE_TAXIWAY_LIGHTS"]
+        = new SGMaterial( taxiway_blue_low_lights );
+
+    // hard coded runway vasi light state
+    ssgSimpleState *rwy_vasi_lights = new ssgSimpleState();
+    rwy_vasi_lights->ref();
+    rwy_vasi_lights->disable( GL_LIGHTING );
+    rwy_vasi_lights->enable ( GL_CULL_FACE ) ;
+    rwy_vasi_lights->enable( GL_TEXTURE_2D );
+    rwy_vasi_lights->enable( GL_BLEND );
+    rwy_vasi_lights->enable( GL_ALPHA_TEST );
+    rwy_vasi_lights->enable( GL_COLOR_MATERIAL );
+    rwy_vasi_lights->setMaterial ( GL_AMBIENT, 1.0, 1.0, 1.0, 1.0 );
+    rwy_vasi_lights->setMaterial ( GL_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+    rwy_vasi_lights->setMaterial ( GL_SPECULAR, 0.0, 0.0, 0.0, 0.0 );
+    rwy_vasi_lights->setMaterial ( GL_EMISSION, 0.0, 0.0, 0.0, 0.0 );
+    rwy_vasi_lights->setTexture( gen_vasi_light_map() );
+    matlib["RWY_VASI_LIGHTS"] = new SGMaterial( rwy_vasi_lights );
+
+    return true;
+}
+
+
+// Load a library of material properties
+bool SGMaterialLib::add_item ( const string &tex_path )
+{
+    string material_name = tex_path;
+    int pos = tex_path.rfind( "/" );
+    material_name = material_name.substr( pos + 1 );
+
+    return add_item( material_name, tex_path );
+}
+
+
+// Load a library of material properties
+bool SGMaterialLib::add_item ( const string &mat_name, const string &full_path )
+{
+    int pos = full_path.rfind( "/" );
+    string tex_name = full_path.substr( pos + 1 );
+    string tex_path = full_path.substr( 0, pos );
+
+    SG_LOG( SG_TERRAIN, SG_INFO, "  Loading material " 
+	    << mat_name << " (" << full_path << ")");
+
+    matlib[mat_name] = new SGMaterial( full_path );
+
+    return true;
+}
+
+
+// Load a library of material properties
+bool SGMaterialLib::add_item ( const string &mat_name, ssgSimpleState *state )
+{
+    SGMaterial *m = new SGMaterial( state );
+
+    SG_LOG( SG_TERRAIN, SG_INFO, "  Loading material given a premade "
+	    << "ssgSimpleState = " << mat_name );
+
+    matlib[mat_name] = m;
+
+    return true;
+}
+
+
+// find a material record by material name
+SGMaterial *SGMaterialLib::find( const string& material ) {
+    SGMaterial *result = NULL;
+    material_map_iterator it = matlib.find( material );
+    if ( it != end() ) {
+	result = it->second;
+	return result;
+    }
+
+    return NULL;
+}
+
+
+// Destructor
+SGMaterialLib::~SGMaterialLib ( void ) {
+    // Free up all the material entries first
+    for ( material_map_iterator it = begin(); it != end(); it++ ) {
+	SGMaterial *slot = it->second;
+	slot->deRef();
+	if ( slot->getRef() <= 0 ) {
+            delete slot;
+        }
+    }
+}
+
+
+// Load one pending "deferred" texture.  Return true if a texture
+// loaded successfully, false if no pending, or error.
+void SGMaterialLib::load_next_deferred() {
+    // container::iterator it = begin();
+    for ( material_map_iterator it = begin(); it != end(); it++ ) {
+	/* we don't need the key, but here's how we'd get it if we wanted it. */
+        // const string &key = it->first;
+	SGMaterial *slot = it->second;
+	if (slot->load_texture())
+	  return;
+    }
+}

simgear/scene/material/matlib.hxx

@@ -0,0 +1,93 @@
+// matlib.hxx -- class to handle material properties
+//
+// Written by Curtis Olson, started May 1998.
+//
+// Copyright (C) 1998 - 2000  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$
+
+
+#ifndef _MATLIB_HXX
+#define _MATLIB_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include <simgear/compiler.h>
+
+#include STL_STRING		// Standard C++ string library
+#include <map>			// STL associative "array"
+#include <vector>		// STL "array"
+
+#include <plib/ssg.h>		// plib include
+
+
+class SGMaterial;
+
+SG_USING_STD(string);
+SG_USING_STD(map);
+SG_USING_STD(vector);
+SG_USING_STD(less);
+
+
+// Material management class
+class SGMaterialLib {
+
+private:
+
+    // associative array of materials
+    typedef map < string, SGMaterial *, less<string> > material_map;
+    typedef material_map::iterator material_map_iterator;
+    typedef material_map::const_iterator const_material_map_iterator;
+
+    material_map matlib;
+
+public:
+
+    // Constructor
+    SGMaterialLib ( void );
+
+    // Load a library of material properties
+    bool load( const string &fg_root, const string& mpath );
+
+    // Add the named texture with default properties
+    bool add_item( const string &tex_path );
+    bool add_item( const string &mat_name, const string &tex_path );
+    bool add_item( const string &mat_name, ssgSimpleState *state );
+
+    // find a material record by material name
+    SGMaterial *find( const string& material );
+
+    /**
+     * Load the next deferred texture, if there is any.
+     */
+    void load_next_deferred();
+
+    material_map_iterator begin() { return matlib.begin(); }
+    const_material_map_iterator begin() const { return matlib.begin(); }
+
+    material_map_iterator end() { return matlib.end(); }
+    const_material_map_iterator end() const { return matlib.end(); }
+
+    // Destructor
+    ~SGMaterialLib ( void );
+};
+
+
+#endif // _MATLIB_HXX