Updated dsp/dsw files for MSVC.

be loaded 5 times! for a lot of wasted texture RAM.  Thanks to Erik H. for
noticing the problem.

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.1
+PROJECT_NUMBER         = 0.3.2
 
 # 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 \
@@ -308,12 +309,11 @@ INPUT                  = \
 	simgear/math \
 	simgear/misc \
 	simgear/route \
+	simgear/scene \
 	simgear/screen \
 	simgear/serial \
 	simgear/sg_inlines.h \
 	simgear/sg_traits.hxx \
-	simgear/sg_zlib.h \
-	simgear/sky \
 	simgear/threads \
 	simgear/timing \
 	simgear/xml
@@ -335,7 +335,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 +385,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 +514,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,78 @@
+/* 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.
+ * - A whole earth tiling/indexing scheme.
+ * - A console debugging output scheme that tracks severity and
+ *   category that can be completely compiled out for a final build release.
+ * - Code to manage "real" time and time zones.
+ * - Code to calculate accurate positions of sun, moon, stars, and
+ *   planets for a given time, date, season, earth location, etc.
+ * - Simple serial, file, and network I/O abstractions
+ * - Code to calculate magnetic variation.
+ * - A variety of coordinate conversion, vector, matrix type math routines.
+ * - An abstraction to hide platform dependent path naming schemes.
+ * - A C++ streams wrapper to handle compress input/output streams.
+ * - 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.
+ * - 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 (and ultra-hires tile rendered screen dumps)
+ * - A sound effects manager.
+ * - A threading abstraction.
+ * - A simple but highly functional XML parser that interfaces nicely
+ *   with the property manager.
+
+ * \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
+
+ * \section install Installation
+ *
+ * \subsection step1 Step 1: Opening the box
+ *  
+ * etc...
+ */
+

Makefile.am

@@ -1,6 +1,7 @@
 EXTRA_DIST = \
 	acinclude.m4 \
 	autogen.sh \
+	DoxygenMain.cxx
 	README.MSVC \
 	README.metakit \
 	README.zlib \

NEWS

@@ -1,3 +1,35 @@
+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
 

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.1)
+AM_INIT_AUTOMAKE(SimGear, 0.3.2)
 
 dnl Specify KAI C++ compiler and flags.
 dnl Borrowed with slight modification from blitz distribution.
@@ -38,21 +38,24 @@ 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
+dnl Used on the Irix platform
 AR="ar"
 ARFLAGS="cru"
-OS=`uname -s`
-if test "$OS" = "IRIX" -o "$OS" = "IRIX64"; then
+case "${host}" in
+*-*-irix*)
     if test "$CXX" = "CC"; then
         AR="CC -ar"
         ARFLAGS="-o"
+        CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility"
     fi
-fi
+    ;;
+esac
 AC_SUBST(AR)
 AC_SUBST(ARFLAGS)
 
-
 if echo $includedir | egrep "simgear$" > /dev/null; then
     echo "includedir is" $includedir "libdir is" $libdir
 else
@@ -60,8 +63,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 +92,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,11 +119,18 @@ 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.
 
@@ -150,12 +147,74 @@ if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h
     CXXFLAGS="$CXXFLAGS -D_REENTRANT"
     CFLAGS="$CFLAGS -D_REENTRANT"
 fi
+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")
 
 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
+dnl check for glut location
+AC_CHECK_HEADER(GL/glut.h)
+if test "x$ac_cv_header_GL_glut_h" = "xyes"; then
+    AC_DEFINE([GLUT_H], "GL/glut.h", [Define as glut.h include location])
+else
+    AC_CHECK_HEADER(GLUT/glut.h)
+    if test "x$ac_cv_header_GLUT_glut_h" = "xyes"; then
+        AC_DEFINE([GLUT_H], "GLUT/glut.h", [Define as glut.h include location])
+    else
+        echo "Neither GL/glut.h nor GLUT/glut.h found.  Cannot continue"
+        exit
+    fi
+fi
+
+dnl check for OpenGL related libraries
+case "${host}" in
+*-*-cygwin* | *-*-mingw32*)
+    dnl CygWin under Windoze.
+
+    echo Win32 specific hacks...
+    AC_DEFINE([WIN32], 1, [Define for Win32 platforms])
+    AC_DEFINE([NOMINMAX], 1, [Define for Win32 platforms])
+
+    LIBS="$LIBS -lglut32 -lglu32 -lopengl32"
+    LIBS="$LIBS -luser32 -lgdi32 -lwinmm"
+
+    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 GLUT -framework OpenGL -framework Carbon -lobjc"
+    ;;
+
+*)
+    dnl X-Windows based machines
+
     AC_CHECK_LIB(X11, XCreateWindow)
     AC_CHECK_LIB(Xext, XShmCreateImage)
     AC_CHECK_LIB(Xi, XGetExtensionVersion)
@@ -163,18 +222,7 @@ if test "x$HOSTTYPE" != "xmacintosh" ; then
     AC_CHECK_LIB(SM, SmcOpenConnection)
     AC_CHECK_LIB(Xt, XtMalloc)
     AC_CHECK_LIB(Xmu, XmuLookupStandardColormap)
-fi
-
-dnl check for OpenGL related libraries
-
-AM_CONDITIONAL(EXTGL_NEEDED, test "x$ac_cv_header_windows_h" = "xyes")
-
-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
-
+    
     AC_CHECK_LIB(GLcore, glNewList)
     if test "x$ac_cv_lib_GLcore_glNewList" = "xno" ; then
 	dnl if no GLcore, check for GL
@@ -203,62 +251,10 @@ elif test "x$ac_cv_header_windows_h" != "xyes" ; then
 	AC_CHECK_LIB(MesaGLU, gluLookAt)
     fi
 
-    dnl check for glut
-    AC_CHECK_LIB(glut, glutGetModifiers)
+    LIBS="$LIBS -lglut"
+    ;;
 
-    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"
@@ -266,7 +262,9 @@ LIBS="$base_LIBS"
 AC_SUBST(base_LIBS)
 AC_SUBST(opengl_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 +307,79 @@ int main() {
   AC_MSG_RESULT(yes)
 )
 
-dnl Check for system installed metakit
+dnl Check for 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."
+    echo
+    echo "MetaKit library not found."
+    echo
+    echo "If your OS does not provide an installable package for MetaKit"
+    echo "you will have to compile and install it first yourself.  A copy"
+    echo "of metakit-$(VERSION).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."
     exit
 fi
 
-AC_LANG_POP
+AC_MSG_CHECKING([for metakit 2.4.3 or newer])
+saved_LIBS="$LIBS"
+LIBS="$saved_LIBS -lmk4"
+AC_TRY_RUN([
+#include <mk4.h>
 
-dnl Specify if we want logging (testing build) or not (release build)
+#define MIN_MK4_VERSION 243
+
+int main() {
+    int major, minor, micro;
+
+    if ( d4_MetaKitLibraryVersion < MIN_MK4_VERSION ) {
+	 return -1;
+    }
+
+    return 0;
+}
+
+],
+  AC_MSG_RESULT(yes),
+  [AC_MSG_RESULT(wrong version);
+   AC_MSG_ERROR([
+
+Install metakit 2.4.3 or later first.
+
+Or, the compiler may not be finding your libmk4.so library.
+Please check the config.log file for specific details of the
+failure if you believe you have the correct metakit version.
+Also, look up this issue in the FlightGear FAQ.])],
+  AC_MSG_RESULT(yes)
+)
+
+LIBS="$saved_LIBS"
+
+AC_LANG_POP
 
 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 +394,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 +406,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 +415,16 @@ 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/tgdb/Makefile \
 	simgear/screen/Makefile \
 	simgear/serial/Makefile \
-	simgear/sky/Makefile \
-	simgear/sky/clouds3d/Makefile \
+	simgear/sound/Makefile \
 	simgear/threads/Makefile \
 	simgear/timing/Makefile \
 	simgear/xgl/Makefile \
@@ -394,9 +445,16 @@ else
     echo "Debug messages: yes"
 fi
 
-echo -n "Automake version: ($AUTO_MAKE_VERSION) "
+echo -n "Automake version: "
 automake --version | head -1
 
+if test "x$ac_cv_header_GL_glut_h" = "xyes"; then
+   echo "With GL/glut.h"
+fi
+if test "x$ac_cv_header_GLUT_glut_h" = "xyes"; then
+   echo "With GLUT/glut.h"
+fi
+
 if test "x$with_jpeg_factory" = "xyes"; then
    echo "With JPEG Factory support"
 else
@@ -408,3 +466,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,9 +10,10 @@ 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 \
 	xml \
 	debug \
 	misc \
@@ -22,10 +23,12 @@ SUBDIRS = \
 	magvar \
 	math \
 	$(METAR_DIRS) \
+	props \
 	route \
+	scene \
 	screen \
 	serial \
-	sky \
+	sound \
 	$(SGTHREAD_DIR) \
 	timing \
 	xgl

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/Makefile.am

@@ -0,0 +1,31 @@
+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

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,12 @@
+
+#ifndef __SG_IOMANIP
+#define __SG_IOMANIP 1
+
+# include <iomanip.h>
+
+namespace std {
+   using ::setw;
+};
+
+#endif // !__SG_IOMANIP
+

simgear/compatibility/iostream

@@ -0,0 +1,40 @@
+
+#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 ::hex;
+  };
+
+# 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,13 @@
+
+#ifndef __SG_SSTREAM
+#define __SG_SSTREAM 1
+
+# include <strstream>
+
+namespace std {
+   typedef ::ostrstream ostringstream;
+   typedef ::istrstream istringstream;
+};
+
+#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

@@ -291,28 +291,24 @@
 #  define SG_HAVE_NATIVE_SGI_COMPILERS
 
 #  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 +317,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/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
@@ -38,7 +32,7 @@ tcp_server_LDADD = \
 	$(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
 
 tcp_client_SOURCES = tcp_client.cxx
 
@@ -48,7 +42,7 @@ tcp_client_LDADD = \
 	$(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
 
 socktest_SOURCES = socktest.cxx
 
@@ -58,7 +52,7 @@ socktest_LDADD = \
 	$(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
 
 lowtest_SOURCES = lowtest.cxx
 

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/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/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,19 @@ 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 );
+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/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

@@ -5,29 +5,30 @@ 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/commands.cxx

@@ -4,8 +4,9 @@
 //
 // $Id$
 
+#include <simgear/props/props_io.hxx>
+
 #include "commands.hxx"
-#include "props_io.hxx"
 
 
 

simgear/misc/commands.hxx

@@ -17,7 +17,7 @@
 #include <map>
 #include <vector>
 
-#include "props.hxx"
+#include <simgear/props/props.hxx>
 
 SG_USING_STD(string);
 SG_USING_STD(map);

simgear/misc/sg_path.cxx

@@ -104,8 +104,19 @@ 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(SG_PATH_SEP);
+    if (index >= 0) {
+	return path.substr(index + 1);
+    } else {
+	return "";
+    }
+}
+  
+
 // get the directory part of the path.
-string SGPath::dir() {
+string SGPath::dir() const {
     int index = path.rfind(SG_PATH_SEP);
     if (index >= 0) {
 	return path.substr(0, index);
@@ -114,6 +125,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) {

simgear/misc/sg_path.hxx

@@ -94,12 +94,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
      */

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] != string("Hello")) {
+		cerr << "failed to read string at index 0" << endl;
+		return 1;
+	}
+	
+	if (tv[1] != string("World")) {
+		cerr << "failed to read string at index 1" << endl;
+		return 1;
+	}
+	
+	if (tv[2] != string("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] != string("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/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,24 @@
+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
+
+INCLUDES = -I$(top_srcdir)

simgear/props/condition.cxx

@@ -0,0 +1,431 @@
+// 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/misc/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

@@ -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);

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/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,250 @@
+// 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);
+
+  ambient[0] = props->getDoubleValue("ambient/r", 0.0);
+  ambient[1] = props->getDoubleValue("ambient/g", 0.0);
+  ambient[2] = props->getDoubleValue("ambient/b", 0.0);
+  ambient[3] = props->getDoubleValue("ambient/a", 0.0);
+
+  diffuse[0] = props->getDoubleValue("diffuse/r", 0.0);
+  diffuse[1] = props->getDoubleValue("diffuse/g", 0.0);
+  diffuse[2] = props->getDoubleValue("diffuse/b", 0.0);
+  diffuse[3] = props->getDoubleValue("diffuse/a", 0.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", 0.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", 0.0);
+
+  shininess = props->getDoubleValue("shininess", 0.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 = 0.0;
+    for (int i = 0; i < 4; i++) {
+        ambient[i] = diffuse[i] = specular[i] = emission[i] = 0.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 );
+#if 0
+    state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
+    state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
+    state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
+#else
+    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 );
+#endif
+}
+
+
+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,611 @@
+// 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 GLUT_H
+
+#include <simgear/compiler.h>
+#include <simgear/constants.h>
+#include <simgear/misc/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, 205 );
+    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, 205 );
+    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 );
+
+    // 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 

simgear/scene/material/matmodel.cxx

@@ -0,0 +1,250 @@
+// matmodel.cxx -- class to handle models tied to a material property
+//
+// Written by David Megginson, started May 1998.
+//
+// Copyright (C) 1998 - 2003  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 <simgear/scene/model/modellib.hxx>
+
+#include "matmodel.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;
+    }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGMatModel.
+////////////////////////////////////////////////////////////////////////
+
+SGMatModel::SGMatModel (const SGPropertyNode * node, double range_m)
+  : _models_loaded(false),
+    _coverage_m2(node->getDoubleValue("coverage-m2", 1000000)),
+    _range_m(range_m)
+{
+				// Sanity check
+  if (_coverage_m2 < 1000) {
+    SG_LOG(SG_INPUT, SG_ALERT, "Random object coverage " << _coverage_m2
+	   << " is too small, forcing, to 1000");
+    _coverage_m2 = 1000;
+  }
+
+				// Note all the model paths
+  vector <SGPropertyNode_ptr> path_nodes = node->getChildren("path");
+  for (unsigned int i = 0; i < path_nodes.size(); i++)
+    _paths.push_back(path_nodes[i]->getStringValue());
+
+				// Note the heading type
+  string hdg = node->getStringValue("heading-type", "fixed");
+  if (hdg == "fixed") {
+    _heading_type = HEADING_FIXED;
+  } else if (hdg == "billboard") {
+    _heading_type = HEADING_BILLBOARD;
+  } else if (hdg == "random") {
+    _heading_type = HEADING_RANDOM;
+  } else {
+    _heading_type = HEADING_FIXED;
+    SG_LOG(SG_INPUT, SG_ALERT, "Unknown heading type: " << hdg
+	   << "; using 'fixed' instead.");
+  }
+
+  // uncomment to preload models
+  // load_models();
+}
+
+SGMatModel::~SGMatModel ()
+{
+  for (unsigned int i = 0; i < _models.size(); i++) {
+    if (_models[i] != 0) {
+      _models[i]->deRef();
+      _models[i] = 0;
+    }
+  }
+}
+
+int
+SGMatModel::get_model_count( SGModelLib *modellib,
+                             const string &fg_root,
+                             SGPropertyNode *prop_root,
+                             double sim_time_sec )
+{
+  load_models( modellib, fg_root, prop_root, sim_time_sec );
+  return _models.size();
+}
+
+inline void
+SGMatModel::load_models ( SGModelLib *modellib,
+                          const string &fg_root,
+                          SGPropertyNode *prop_root,
+                          double sim_time_sec )
+{
+				// Load model only on demand
+  if (!_models_loaded) {
+    for (unsigned int i = 0; i < _paths.size(); i++) {
+      ssgEntity *entity = modellib->load_model( fg_root, _paths[i],
+                                                prop_root, sim_time_sec );
+      if (entity != 0) {
+                                // FIXME: this stuff can be handled
+                                // in the XML wrapper as well (at least,
+                                // the billboarding should be handled
+                                // there).
+	float ranges[] = {0, _range_m};
+	ssgRangeSelector * lod = new ssgRangeSelector;
+        lod->ref();
+        lod->setRanges(ranges, 2);
+	if (_heading_type == HEADING_BILLBOARD) {
+	  ssgCutout * cutout = new ssgCutout(false);
+	  cutout->addKid(entity);
+	  lod->addKid(cutout);
+	} else {
+	  lod->addKid(entity);
+	}
+	_models.push_back(lod);
+      } else {
+	SG_LOG(SG_INPUT, SG_ALERT, "Failed to load object " << _paths[i]);
+      }
+    }
+  }
+  _models_loaded = true;
+}
+
+ssgEntity *
+SGMatModel::get_model( int index,
+                       SGModelLib *modellib,
+                       const string &fg_root,
+                       SGPropertyNode *prop_root,
+                       double sim_time_sec )
+{
+  load_models( modellib, fg_root, prop_root, sim_time_sec ); // comment this out if preloading models
+  return _models[index];
+}
+
+ssgEntity *
+SGMatModel::get_random_model( SGModelLib *modellib,
+                              const string &fg_root,
+                              SGPropertyNode *prop_root,
+                              double sim_time_sec )
+{
+  load_models( modellib, fg_root, prop_root, sim_time_sec ); // comment this out if preloading models
+  int nModels = _models.size();
+  int index = int(sg_random() * nModels);
+  if (index >= nModels)
+    index = 0;
+  return _models[index];
+}
+
+double
+SGMatModel::get_coverage_m2 () const
+{
+  return _coverage_m2;
+}
+
+SGMatModel::HeadingType
+SGMatModel::get_heading_type () const
+{
+  return _heading_type;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGMatModelGroup.
+////////////////////////////////////////////////////////////////////////
+
+SGMatModelGroup::SGMatModelGroup (SGPropertyNode * node)
+  : _range_m(node->getDoubleValue("range-m", 2000))
+{
+				// Load the object subnodes
+  vector<SGPropertyNode_ptr> object_nodes =
+    ((SGPropertyNode *)node)->getChildren("object");
+  for (unsigned int i = 0; i < object_nodes.size(); i++) {
+    const SGPropertyNode * object_node = object_nodes[i];
+    if (object_node->hasChild("path"))
+      _objects.push_back(new SGMatModel(object_node, _range_m));
+    else
+      SG_LOG(SG_INPUT, SG_ALERT, "No path supplied for object");
+  }
+}
+
+SGMatModelGroup::~SGMatModelGroup ()
+{
+  for (unsigned int i = 0; i < _objects.size(); i++) {
+    delete _objects[i];
+    _objects[i] = 0;
+  }
+}
+
+double
+SGMatModelGroup::get_range_m () const
+{
+  return _range_m;
+}
+
+int
+SGMatModelGroup::get_object_count () const
+{
+  return _objects.size();
+}
+
+SGMatModel *
+SGMatModelGroup::get_object (int index) const
+{
+  return _objects[index];
+}
+
+
+// end of matmodel.cxx

simgear/scene/material/matmodel.hxx

@@ -0,0 +1,202 @@
+// matmodel.hxx -- class to handle models tied to a material property
+//
+// Written by David Megginson, December 2001
+//
+// Copyright (C) 1998 - 2003  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_MODEL_HXX
+#define _SG_MAT_MODEL_HXX
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include <simgear/compiler.h>
+
+#include STL_STRING      // Standard C++ string library
+
+#include <plib/sg.h>
+#include <plib/ssg.h>
+
+#include <simgear/props/props.hxx>
+
+SG_USING_STD(string);
+
+
+class SGMatModelGroup;
+class SGModelLib;
+
+
+/**
+ * A randomly-placeable object.
+ *
+ * SGMaterial uses this class to keep track of the model(s) and
+ * parameters for a single instance of a randomly-placeable object.
+ * The object can have more than one variant model (i.e. slightly
+ * different shapes of trees), but they are considered equivalent
+ * and interchangeable.
+ */
+class SGMatModel {
+
+public:
+
+    /**
+     * The heading type for a randomly-placed object.
+     */
+    enum HeadingType {
+        HEADING_FIXED,
+        HEADING_BILLBOARD,
+        HEADING_RANDOM
+    };
+
+    /**
+     * Get the number of variant models available for the object.
+     *
+     * @return The number of variant models.
+     */
+    int get_model_count( SGModelLib *modellib,
+                         const string &fg_root,
+                         SGPropertyNode *prop_root,
+                         double sim_time_sec );
+
+
+    /**
+     * Get a specific variant model for the object.
+     *
+     * @param index The index of the model.
+     * @return The model.
+     */
+    ssgEntity *get_model( int index,
+                          SGModelLib *modellib,
+                          const string &fg_root,
+                          SGPropertyNode *prop_root,
+                          double sim_time_sec );
+
+
+    /**
+     * Get a randomly-selected variant model for the object.
+     *
+     * @return A randomly select model from the variants.
+     */
+    ssgEntity *get_random_model( SGModelLib *modellib,
+                                 const string &fg_root,
+                                 SGPropertyNode *prop_root,
+                                 double sim_time_sec );
+
+
+    /**
+     * Get the average number of meters^2 occupied by each instance.
+     *
+     * @return The coverage in meters^2.
+     */
+    double get_coverage_m2 () const;
+
+
+    /**
+     * Get the heading type for the object.
+     *
+     * @return The heading type.
+     */
+    HeadingType get_heading_type () const;
+
+protected:
+
+    friend class SGMatModelGroup;
+
+    SGMatModel (const SGPropertyNode * node, double range_m);
+
+    virtual ~SGMatModel ();
+
+private:
+
+    /**
+     * Actually load the models.
+     *
+     * This class uses lazy loading so that models won't be held
+     * in memory for materials that are never referenced.
+     */
+    void load_models( SGModelLib *modellib,
+                      const string &fg_root,
+                      SGPropertyNode *prop_root,
+                      double sim_time_sec );
+
+    vector<string> _paths;
+    mutable vector<ssgEntity *> _models;
+    mutable bool _models_loaded;
+    double _coverage_m2;
+    double _range_m;
+    HeadingType _heading_type;
+};
+
+
+/**
+ * A collection of related objects with the same visual range.
+ *
+ * Grouping objects with the same range together significantly
+ * reduces the memory requirements of randomly-placed objects.
+ * Each SGMaterial instance keeps a (possibly-empty) list of
+ * object groups for placing randomly on the scenery.
+ */
+class SGMatModelGroup {
+
+public:
+
+    virtual ~SGMatModelGroup ();
+
+
+    /**
+     * Get the visual range of the object in meters.
+     *
+     * @return The visual range.
+     */
+    double get_range_m () const;
+
+
+    /**
+     * Get the number of objects in the group.
+     *
+     * @return The number of objects.
+     */
+    int get_object_count () const;
+
+
+    /**
+     * Get a specific object.
+     *
+     * @param index The object's index, zero-based.
+     * @return The object selected.
+     */
+    SGMatModel * get_object (int index) const;
+
+protected:
+
+    friend class SGMaterial;
+
+    SGMatModelGroup (SGPropertyNode * node);
+
+private:
+
+    double _range_m;
+    vector<SGMatModel *> _objects;
+
+};
+
+
+#endif // _SG_MAT_MODEL_HXX 

simgear/scene/model/.cvsignore

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

simgear/scene/model/Makefile.am

@@ -0,0 +1,21 @@
+includedir = @includedir@/scene/model
+
+lib_LIBRARIES = libsgmodel.a
+
+noinst_HEADERS =
+
+include_HEADERS = \
+	animation.hxx \
+	location.hxx \
+	model.hxx \
+	modellib.hxx \
+	placement.hxx
+
+libsgmodel_a_SOURCES = \
+	animation.cxx \
+	location.cxx \
+	model.cxx \
+	modellib.cxx \
+	placement.cxx
+
+INCLUDES = -I$(top_srcdir)

simgear/scene/model/animation.cxx

@@ -0,0 +1,379 @@
+// animation.hxx - classes to manage model animation.
+// Written by David Megginson, started 2002.
+//
+// This file is in the Public Domain, and comes with no warranty.
+
+
+#include <string.h>             // for strcmp()
+
+#include <plib/sg.h>
+#include <plib/ssg.h>
+#include <plib/ul.h>
+
+#include <simgear/math/interpolater.hxx>
+#include <simgear/props/condition.hxx>
+#include <simgear/props/props.hxx>
+
+#include "animation.hxx"
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Static utility functions.
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Set up the transform matrix for a spin or rotation.
+ */
+static void
+set_rotation (sgMat4 &matrix, double position_deg,
+              sgVec3 &center, sgVec3 &axis)
+{
+ float temp_angle = -position_deg * SG_DEGREES_TO_RADIANS ;
+ 
+ float s = (float) sin ( temp_angle ) ;
+ float c = (float) cos ( temp_angle ) ;
+ float t = SG_ONE - c ;
+
+ // axis was normalized at load time 
+ // hint to the compiler to put these into FP registers
+ float x = axis[0];
+ float y = axis[1];
+ float z = axis[2];
+
+ matrix[0][0] = t * x * x + c ;
+ matrix[0][1] = t * y * x - s * z ;
+ matrix[0][2] = t * z * x + s * y ;
+ matrix[0][3] = SG_ZERO;
+ 
+ matrix[1][0] = t * x * y + s * z ;
+ matrix[1][1] = t * y * y + c ;
+ matrix[1][2] = t * z * y - s * x ;
+ matrix[1][3] = SG_ZERO;
+ 
+ matrix[2][0] = t * x * z - s * y ;
+ matrix[2][1] = t * y * z + s * x ;
+ matrix[2][2] = t * z * z + c ;
+ matrix[2][3] = SG_ZERO;
+
+  // hint to the compiler to put these into FP registers
+ x = center[0];
+ y = center[1];
+ z = center[2];
+ 
+ matrix[3][0] = x - x*matrix[0][0] - y*matrix[1][0] - z*matrix[2][0];
+ matrix[3][1] = y - x*matrix[0][1] - y*matrix[1][1] - z*matrix[2][1];
+ matrix[3][2] = z - x*matrix[0][2] - y*matrix[1][2] - z*matrix[2][2];
+ matrix[3][3] = SG_ONE;
+}
+
+/**
+ * Set up the transform matrix for a translation.
+ */
+static void
+set_translation (sgMat4 &matrix, double position_m, sgVec3 &axis)
+{
+  sgVec3 xyz;
+  sgScaleVec3(xyz, axis, position_m);
+  sgMakeTransMat4(matrix, xyz);
+}
+
+
+/**
+ * Read an interpolation table from properties.
+ */
+static SGInterpTable *
+read_interpolation_table (SGPropertyNode_ptr props)
+{
+  SGPropertyNode_ptr table_node = props->getNode("interpolation");
+  if (table_node != 0) {
+    SGInterpTable * table = new SGInterpTable();
+    vector<SGPropertyNode_ptr> entries = table_node->getChildren("entry");
+    for (unsigned int i = 0; i < entries.size(); i++)
+      table->addEntry(entries[i]->getDoubleValue("ind", 0.0),
+                      entries[i]->getDoubleValue("dep", 0.0));
+    return table;
+  } else {
+    return 0;
+  }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGAnimation
+////////////////////////////////////////////////////////////////////////
+
+// Initialize the static data member
+double SGAnimation::sim_time_sec = 0.0;
+
+SGAnimation::SGAnimation (SGPropertyNode_ptr props, ssgBranch * branch)
+    : _branch(branch)
+{
+    _branch->setName(props->getStringValue("name", 0));
+}
+
+SGAnimation::~SGAnimation ()
+{
+}
+
+void
+SGAnimation::init ()
+{
+}
+
+void
+SGAnimation::update()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGNullAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGNullAnimation::SGNullAnimation (SGPropertyNode_ptr props)
+  : SGAnimation(props, new ssgBranch)
+{
+}
+
+SGNullAnimation::~SGNullAnimation ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGRangeAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGRangeAnimation::SGRangeAnimation (SGPropertyNode_ptr props)
+  : SGAnimation(props, new ssgRangeSelector)
+{
+    float ranges[] = { props->getFloatValue("min-m", 0),
+                       props->getFloatValue("max-m", 5000) };
+    ((ssgRangeSelector *)_branch)->setRanges(ranges, 2);
+                       
+}
+
+SGRangeAnimation::~SGRangeAnimation ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGBillboardAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGBillboardAnimation::SGBillboardAnimation (SGPropertyNode_ptr props)
+    : SGAnimation(props, new ssgCutout(props->getBoolValue("spherical", true)))
+{
+}
+
+SGBillboardAnimation::~SGBillboardAnimation ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGSelectAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGSelectAnimation::SGSelectAnimation( SGPropertyNode *prop_root,
+                                  SGPropertyNode_ptr props )
+  : SGAnimation(props, new ssgSelector),
+    _condition(0)
+{
+  SGPropertyNode_ptr node = props->getChild("condition");
+  if (node != 0)
+    _condition = sgReadCondition(prop_root, node);
+}
+
+SGSelectAnimation::~SGSelectAnimation ()
+{
+  delete _condition;
+}
+
+void
+SGSelectAnimation::update()
+{
+  if (_condition != 0 && _condition->test()) 
+      ((ssgSelector *)_branch)->select(0xffff);
+  else
+      ((ssgSelector *)_branch)->select(0x0000);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGSpinAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGSpinAnimation::SGSpinAnimation( SGPropertyNode *prop_root,
+                              SGPropertyNode_ptr props,
+                              double sim_time_sec )
+  : SGAnimation(props, new ssgTransform),
+    _prop((SGPropertyNode *)prop_root->getNode(props->getStringValue("property", "/null"), true)),
+    _factor(props->getDoubleValue("factor", 1.0)),
+    _position_deg(props->getDoubleValue("starting-position-deg", 0)),
+    _last_time_sec( sim_time_sec )
+{
+    _center[0] = props->getFloatValue("center/x-m", 0);
+    _center[1] = props->getFloatValue("center/y-m", 0);
+    _center[2] = props->getFloatValue("center/z-m", 0);
+    _axis[0] = props->getFloatValue("axis/x", 0);
+    _axis[1] = props->getFloatValue("axis/y", 0);
+    _axis[2] = props->getFloatValue("axis/z", 0);
+    sgNormalizeVec3(_axis);
+}
+
+SGSpinAnimation::~SGSpinAnimation ()
+{
+}
+
+void
+SGSpinAnimation::update()
+{
+  double dt = sim_time_sec - _last_time_sec;
+  _last_time_sec = sim_time_sec;
+
+  float velocity_rpms = (_prop->getDoubleValue() * _factor / 60.0);
+  _position_deg += (dt * velocity_rpms * 360);
+  while (_position_deg < 0)
+    _position_deg += 360.0;
+  while (_position_deg >= 360.0)
+    _position_deg -= 360.0;
+  set_rotation(_matrix, _position_deg, _center, _axis);
+  ((ssgTransform *)_branch)->setTransform(_matrix);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGTimedAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGTimedAnimation::SGTimedAnimation (SGPropertyNode_ptr props)
+  : SGAnimation(props, new ssgSelector),
+    _duration_sec(props->getDoubleValue("duration-sec", 1.0)),
+    _last_time_sec(0),
+    _step(-1)
+{
+}
+
+SGTimedAnimation::~SGTimedAnimation ()
+{
+}
+
+void
+SGTimedAnimation::update()
+{
+    if ((sim_time_sec - _last_time_sec) >= _duration_sec) {
+        _last_time_sec = sim_time_sec;
+        _step++;
+        if (_step >= getBranch()->getNumKids())
+            _step = 0;
+        ((ssgSelector *)getBranch())->selectStep(_step);
+    }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGRotateAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGRotateAnimation::SGRotateAnimation( SGPropertyNode *prop_root,
+                                  SGPropertyNode_ptr props )
+    : SGAnimation(props, new ssgTransform),
+      _prop((SGPropertyNode *)prop_root->getNode(props->getStringValue("property", "/null"), true)),
+      _offset_deg(props->getDoubleValue("offset-deg", 0.0)),
+      _factor(props->getDoubleValue("factor", 1.0)),
+      _table(read_interpolation_table(props)),
+      _has_min(props->hasValue("min-deg")),
+      _min_deg(props->getDoubleValue("min-deg")),
+      _has_max(props->hasValue("max-deg")),
+      _max_deg(props->getDoubleValue("max-deg")),
+      _position_deg(props->getDoubleValue("starting-position-deg", 0))
+{
+  _center[0] = props->getFloatValue("center/x-m", 0);
+  _center[1] = props->getFloatValue("center/y-m", 0);
+  _center[2] = props->getFloatValue("center/z-m", 0);
+  _axis[0] = props->getFloatValue("axis/x", 0);
+  _axis[1] = props->getFloatValue("axis/y", 0);
+  _axis[2] = props->getFloatValue("axis/z", 0);
+  sgNormalizeVec3(_axis);
+}
+
+SGRotateAnimation::~SGRotateAnimation ()
+{
+  delete _table;
+}
+
+void
+SGRotateAnimation::update()
+{
+  if (_table == 0) {
+   _position_deg = _prop->getDoubleValue() * _factor + _offset_deg;
+   if (_has_min && _position_deg < _min_deg)
+     _position_deg = _min_deg;
+   if (_has_max && _position_deg > _max_deg)
+     _position_deg = _max_deg;
+  } else {
+    _position_deg = _table->interpolate(_prop->getDoubleValue());
+  }
+  set_rotation(_matrix, _position_deg, _center, _axis);
+  ((ssgTransform *)_branch)->setTransform(_matrix);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGTranslateAnimation
+////////////////////////////////////////////////////////////////////////
+
+SGTranslateAnimation::SGTranslateAnimation( SGPropertyNode *prop_root,
+                                        SGPropertyNode_ptr props )
+  : SGAnimation(props, new ssgTransform),
+      _prop((SGPropertyNode *)prop_root->getNode(props->getStringValue("property", "/null"), true)),
+    _offset_m(props->getDoubleValue("offset-m", 0.0)),
+    _factor(props->getDoubleValue("factor", 1.0)),
+    _table(read_interpolation_table(props)),
+    _has_min(props->hasValue("min-m")),
+    _min_m(props->getDoubleValue("min-m")),
+    _has_max(props->hasValue("max-m")),
+    _max_m(props->getDoubleValue("max-m")),
+    _position_m(props->getDoubleValue("starting-position-m", 0))
+{
+  _axis[0] = props->getFloatValue("axis/x", 0);
+  _axis[1] = props->getFloatValue("axis/y", 0);
+  _axis[2] = props->getFloatValue("axis/z", 0);
+  sgNormalizeVec3(_axis);
+}
+
+SGTranslateAnimation::~SGTranslateAnimation ()
+{
+  delete _table;
+}
+
+void
+SGTranslateAnimation::update()
+{
+  if (_table == 0) {
+    _position_m = (_prop->getDoubleValue() + _offset_m) * _factor;
+    if (_has_min && _position_m < _min_m)
+      _position_m = _min_m;
+    if (_has_max && _position_m > _max_m)
+      _position_m = _max_m;
+  } else {
+    _position_m = _table->interpolate(_prop->getDoubleValue());
+  }
+  set_translation(_matrix, _position_m, _axis);
+  ((ssgTransform *)_branch)->setTransform(_matrix);
+}
+
+
+// end of animation.cxx

simgear/scene/model/animation.hxx

@@ -0,0 +1,224 @@
+// animation.hxx - classes to manage model animation.
+// Written by David Megginson, started 2002.
+//
+// This file is in the Public Domain, and comes with no warranty.
+
+#ifndef _SG_ANIMATION_HXX
+#define _SG_ANIMATION_HXX 1
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+#include <vector>
+
+SG_USING_STD(vector);
+
+#include <plib/sg.h>
+#include <plib/ssg.h>
+
+#include <simgear/math/point3d.hxx>
+#include <simgear/props/props.hxx>
+
+
+// Don't pull in the headers, since we don't need them here.
+class SGInterpTable;
+class SGCondition;
+
+
+// Has anyone done anything *really* stupid, like making min and max macros?
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////////
+// Animation classes
+//////////////////////////////////////////////////////////////////////
+
+/**
+ * Abstract base class for all animations.
+ */
+class SGAnimation :  public ssgBase
+{
+public:
+
+  SGAnimation (SGPropertyNode_ptr props, ssgBranch * branch);
+
+  virtual ~SGAnimation ();
+
+  /**
+   * Get the SSG branch holding the animation.
+   */
+  virtual ssgBranch * getBranch () { return _branch; }
+
+  /**
+   * Initialize the animation, after children have been added.
+   */
+  virtual void init ();
+
+  /**
+   * Update the animation.
+   */
+  virtual void update();
+
+  /**
+   * Set the value of sim_time_sec.  This needs to be called every
+   * frame in order for the time based animations to work correctly.
+   */
+  static void set_sim_time_sec( double val ) { sim_time_sec = val; }
+
+protected:
+
+  static double sim_time_sec;
+
+  ssgBranch * _branch;
+
+};
+
+
+/**
+ * A no-op animation.
+ */
+class SGNullAnimation : public SGAnimation
+{
+public:
+  SGNullAnimation (SGPropertyNode_ptr props);
+  virtual ~SGNullAnimation ();
+};
+
+
+/**
+ * A range, or level-of-detail (LOD) animation.
+ */
+class SGRangeAnimation : public SGAnimation
+{
+public:
+  SGRangeAnimation (SGPropertyNode_ptr props);
+  virtual ~SGRangeAnimation ();
+};
+
+
+/**
+ * Animation to turn and face the screen.
+ */
+class SGBillboardAnimation : public SGAnimation
+{
+public:
+  SGBillboardAnimation (SGPropertyNode_ptr props);
+  virtual ~SGBillboardAnimation ();
+};
+
+
+/**
+ * Animation to select alternative versions of the same object.
+ */
+class SGSelectAnimation : public SGAnimation
+{
+public:
+  SGSelectAnimation( SGPropertyNode *prop_root,
+                   SGPropertyNode_ptr props );
+  virtual ~SGSelectAnimation ();
+  virtual void update();
+private:
+  SGCondition * _condition;
+};
+
+
+/**
+ * Animation to spin an object around a center point.
+ *
+ * This animation rotates at a specific velocity.
+ */
+class SGSpinAnimation : public SGAnimation
+{
+public:
+  SGSpinAnimation( SGPropertyNode *prop_root,
+                 SGPropertyNode_ptr props,
+                 double sim_time_sec );
+  virtual ~SGSpinAnimation ();
+  virtual void update();
+private:
+  SGPropertyNode_ptr _prop;
+  double _factor;
+  double _position_deg;
+  double _last_time_sec;
+  sgMat4 _matrix;
+  sgVec3 _center;
+  sgVec3 _axis;
+};
+
+
+/**
+ * Animation to draw objects for a specific amount of time each.
+ */
+class SGTimedAnimation : public SGAnimation
+{
+public:
+    SGTimedAnimation (SGPropertyNode_ptr props);
+    virtual ~SGTimedAnimation ();
+    virtual void update();
+private:
+    double _duration_sec;
+    double _last_time_sec;
+    int _step;
+};
+
+
+/**
+ * Animation to rotate an object around a center point.
+ *
+ * This animation rotates to a specific position.
+ */
+class SGRotateAnimation : public SGAnimation
+{
+public:
+  SGRotateAnimation( SGPropertyNode *prop_root, SGPropertyNode_ptr props );
+  virtual ~SGRotateAnimation ();
+  virtual void update();
+private:
+  SGPropertyNode_ptr _prop;
+  double _offset_deg;
+  double _factor;
+  SGInterpTable * _table;
+  bool _has_min;
+  double _min_deg;
+  bool _has_max;
+  double _max_deg;
+  double _position_deg;
+  sgMat4 _matrix;
+  sgVec3 _center;
+  sgVec3 _axis;
+};
+
+
+/**
+ * Animation to slide along an axis.
+ */
+class SGTranslateAnimation : public SGAnimation
+{
+public:
+  SGTranslateAnimation( SGPropertyNode *prop_root,
+                      SGPropertyNode_ptr props );
+  virtual ~SGTranslateAnimation ();
+  virtual void update();
+private:
+  SGPropertyNode_ptr _prop;
+  double _offset_m;
+  double _factor;
+  SGInterpTable * _table;
+  bool _has_min;
+  double _min_m;
+  bool _has_max;
+  double _max_m;
+  double _position_m;
+  sgMat4 _matrix;
+  sgVec3 _axis;
+};
+
+
+#endif // _SG_ANIMATION_HXX

simgear/scene/model/location.cxx

@@ -0,0 +1,280 @@
+// location.cxx -- class for determining model location in the flightgear world.
+//
+// Written by Jim Wilson, David Megginson, started April 2002.
+// Based largely on code by Curtis Olson and Norman Vine.
+//
+// Copyright (C) 2002  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$
+
+
+#include <simgear/compiler.h>
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/constants.h>
+#include <simgear/math/point3d.hxx>
+#include <simgear/math/polar3d.hxx>
+#include <simgear/math/sg_geodesy.hxx>
+#include <simgear/math/vector.hxx>
+
+#include "location.hxx"
+
+
+/**
+ * make model transformation Matrix - based on optimizations by NHV
+ */
+static void MakeTRANS( sgMat4 dst, const double Theta,
+			const double Phi, const double Psi, 
+                        const sgMat4 UP)
+{
+    SGfloat cosTheta = (SGfloat) cos(Theta);
+    SGfloat sinTheta = (SGfloat) sin(Theta);
+    SGfloat cosPhi   = (SGfloat) cos(Phi);
+    SGfloat sinPhi   = (SGfloat) sin(Phi);
+    SGfloat sinPsi   = (SGfloat) sin(Psi) ;
+    SGfloat cosPsi   = (SGfloat) cos(Psi) ;
+
+    sgMat4 tmp;
+	
+    tmp[0][0] = cosPhi * cosTheta;
+    tmp[0][1] =	sinPhi * cosPsi + cosPhi * -sinTheta * -sinPsi;
+    tmp[0][2] =	sinPhi * sinPsi + cosPhi * -sinTheta * cosPsi;
+
+    tmp[1][0] = -sinPhi * cosTheta;
+    tmp[1][1] =	cosPhi * cosPsi + -sinPhi * -sinTheta * -sinPsi;
+    tmp[1][2] =	cosPhi * sinPsi + -sinPhi * -sinTheta * cosPsi;
+	
+    tmp[2][0] = sinTheta;
+    tmp[2][1] =	cosTheta * -sinPsi;
+    tmp[2][2] =	cosTheta * cosPsi;
+	
+    float a = UP[0][0];
+    float b = UP[1][0];
+    float c = UP[2][0];
+    dst[2][0] = a*tmp[0][0] + b*tmp[0][1] + c*tmp[0][2] ;
+    dst[1][0] = a*tmp[1][0] + b*tmp[1][1] + c*tmp[1][2] ;
+    dst[0][0] = -(a*tmp[2][0] + b*tmp[2][1] + c*tmp[2][2]) ;
+    dst[3][0] = SG_ZERO ;
+
+    a = UP[0][1];
+    b = UP[1][1];
+    c = UP[2][1];
+    dst[2][1] = a*tmp[0][0] + b*tmp[0][1] + c*tmp[0][2] ;
+    dst[1][1] = a*tmp[1][0] + b*tmp[1][1] + c*tmp[1][2] ;
+    dst[0][1] = -(a*tmp[2][0] + b*tmp[2][1] + c*tmp[2][2]) ;
+    dst[3][1] = SG_ZERO ;
+
+    a = UP[0][2];
+    c = UP[2][2];
+    dst[2][2] = a*tmp[0][0] + c*tmp[0][2] ;
+    dst[1][2] = a*tmp[1][0] + c*tmp[1][2] ;
+    dst[0][2] = -(a*tmp[2][0] + c*tmp[2][2]) ;
+    dst[3][2] = SG_ZERO ;
+
+    dst[2][3] = SG_ZERO ;
+    dst[1][3] = SG_ZERO ;
+    dst[0][3] = SG_ZERO ;
+    dst[3][3] = SG_ONE ;
+
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGLocation.
+////////////////////////////////////////////////////////////////////////
+
+// Constructor
+SGLocation::SGLocation( void ):
+    _dirty(true),
+    _lon_deg(0),
+    _lat_deg(0),
+    _alt_ft(0),
+    _roll_deg(0),
+    _pitch_deg(0),
+    _heading_deg(0),
+    _cur_elev_m(0),
+    _tile_center(0)
+{
+    sgdZeroVec3(_absolute_view_pos);
+    sgZeroVec3(_relative_view_pos);
+    sgZeroVec3(_zero_elev_view_pos);
+    sgMakeRotMat4( UP, 0.0, 0.0, 0.0 );
+    sgMakeRotMat4( TRANS, 0.0, 0.0, 0.0 );
+}
+
+
+// Destructor
+SGLocation::~SGLocation( void ) {
+}
+
+void
+SGLocation::init ()
+{
+}
+
+void
+SGLocation::bind ()
+{
+}
+
+void
+SGLocation::unbind ()
+{
+}
+
+void
+SGLocation::setPosition (double lon_deg, double lat_deg, double alt_ft)
+{
+  _dirty = true;
+  _lon_deg = lon_deg;
+  _lat_deg = lat_deg;
+  _alt_ft = alt_ft;
+}
+
+void
+SGLocation::setOrientation (double roll_deg, double pitch_deg, double heading_deg)
+{
+  _dirty = true;
+  _roll_deg = roll_deg;
+  _pitch_deg = pitch_deg;
+  _heading_deg = heading_deg;
+}
+
+double *
+SGLocation::get_absolute_view_pos( const Point3D scenery_center ) 
+{
+    if ( _dirty ) {
+        recalc( scenery_center );
+    }
+    return _absolute_view_pos;
+}
+
+float *
+SGLocation::getRelativeViewPos( const Point3D scenery_center ) 
+{
+    if ( _dirty ) {
+        recalc( scenery_center );
+    }
+    return _relative_view_pos;
+}
+
+float *
+SGLocation::getZeroElevViewPos( const Point3D scenery_center ) 
+{
+    if ( _dirty ) {
+        recalc( scenery_center );
+    }
+    return _zero_elev_view_pos;
+}
+
+
+// recalc() is done every time one of the setters is called (making the 
+// cached data "dirty") on the next "get".  It calculates all the outputs 
+// for viewer.
+void
+SGLocation::recalc( const Point3D scenery_center )
+{
+
+  recalcPosition( _lon_deg, _lat_deg, _alt_ft, scenery_center );
+
+  // Make the world up rotation matrix for eye positioin...
+  sgMakeRotMat4( UP, _lon_deg, 0.0, -_lat_deg );
+
+
+  // get the world up radial vector from planet center for output
+  sgSetVec3( _world_up, UP[0][0], UP[0][1], UP[0][2] );
+
+  // Creat local matrix with current geodetic position.  Converting
+  // the orientation (pitch/roll/heading) to vectors.
+  MakeTRANS( TRANS, _pitch_deg * SG_DEGREES_TO_RADIANS,
+                      _roll_deg * SG_DEGREES_TO_RADIANS,
+                      -_heading_deg * SG_DEGREES_TO_RADIANS,
+                      UP);
+
+  // Given a vector pointing straight down (-Z), map into onto the
+  // local plane representing "horizontal".  This should give us the
+  // local direction for moving "south".
+  sgVec3 minus_z;
+  sgSetVec3( minus_z, 0.0, 0.0, -1.0 );
+
+  sgmap_vec_onto_cur_surface_plane(_world_up, _relative_view_pos, minus_z,
+				     _surface_south);
+  sgNormalizeVec3(_surface_south);
+
+  // now calculate the surface east vector
+  sgVec3 world_down;
+  sgNegateVec3(world_down, _world_up);
+  sgVectorProductVec3(_surface_east, _surface_south, world_down);
+
+  set_clean();
+}
+
+void
+SGLocation::recalcPosition( double lon_deg, double lat_deg, double alt_ft,
+                            const Point3D scenery_center ) const
+{
+  double sea_level_radius_m;
+  double lat_geoc_rad;
+
+
+				// Convert from geodetic to geocentric
+				// coordinates.
+  sgGeodToGeoc(lat_deg * SGD_DEGREES_TO_RADIANS,
+	       alt_ft * SG_FEET_TO_METER,
+	       &sea_level_radius_m,
+	       &lat_geoc_rad);
+
+				// Calculate the cartesian coordinates
+				// of point directly below at sea level.
+                                // aka Zero Elevation Position
+  Point3D p = Point3D(lon_deg * SG_DEGREES_TO_RADIANS,
+		      lat_geoc_rad,
+		      sea_level_radius_m);
+  Point3D tmp = sgPolarToCart3d(p) - _tile_center;
+  sgSetVec3(_zero_elev_view_pos, tmp[0], tmp[1], tmp[2]);
+
+				// Calculate the absolute view position
+				// in fgfs coordinates.
+                                // aka Absolute View Position
+  p.setz(p.radius() + alt_ft * SG_FEET_TO_METER);
+  tmp = sgPolarToCart3d(p);
+  sgdSetVec3(_absolute_view_pos, tmp[0], tmp[1], tmp[2]);
+
+				// Calculate the relative view position
+				// from the scenery center.
+                                // aka Relative View Position
+
+  // FIXME: view position should ONLY be calculated in the viewer...
+  // Anything else should calculate their own positions relative to the 
+  // viewer's tile_center.
+  sgdVec3 center;
+  sgdSetVec3( center,
+              scenery_center.x(), scenery_center.y(), scenery_center.z() );
+  sgdVec3 view_pos;
+  sgdSubVec3(view_pos, _absolute_view_pos, center);
+  sgSetVec3(_relative_view_pos, view_pos);
+
+}
+
+void
+SGLocation::update (int dt)
+{
+}

simgear/scene/model/location.hxx

@@ -0,0 +1,185 @@
+// location.hxx -- class for determining model location in the flightgear world.
+//
+// Written by Jim Wilson, David Megginson, started April 2002.
+//
+// Copyright (C) 2002  Jim Wilson, David Megginson
+//
+// 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_LOCATION_HXX
+#define _SG_LOCATION_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include <simgear/compiler.h>
+#include <simgear/constants.h>
+#include <simgear/math/point3d.hxx>
+
+#include <plib/sg.h>		// plib include
+
+
+// Define a structure containing view information
+class SGLocation
+{
+
+public:
+
+    // Constructor
+    SGLocation( void );
+
+    // Destructor
+    virtual ~SGLocation( void );
+
+    //////////////////////////////////////////////////////////////////////
+    // Part 1: standard FGSubsystem implementation.
+    //////////////////////////////////////////////////////////////////////
+
+    virtual void init ();
+    virtual void bind ();
+    virtual void unbind ();
+    void update (int dt);
+
+
+    //////////////////////////////////////////////////////////////////////
+    // Part 2: user settings.
+    //////////////////////////////////////////////////////////////////////
+
+    // Geodetic position of model...
+    virtual double getLongitude_deg () const { return _lon_deg; }
+    virtual double getLatitude_deg () const { return _lat_deg; }
+    virtual double getAltitudeASL_ft () const { return _alt_ft; }
+    virtual void setPosition (double lon_deg, double lat_deg, double alt_ft);
+
+
+    // Reference orientation rotations...
+    //   These are rotations that represent the plane attitude effect on
+    //   the view (in Pilot view).  IE The view frustrum rotates as the plane
+    //   turns, pitches, and rolls.
+    //   In model view (lookat/chaseview) these end up changing the angle that
+    //   the eye is looking at the ojbect (ie the model).
+    //   FIXME: the FGModel class should have its own version of these so that
+    //   it can generate it's own model rotations.
+    virtual double getRoll_deg () const { return _roll_deg; }
+    virtual double getPitch_deg () const {return _pitch_deg; }
+    virtual double getHeading_deg () const {return _heading_deg; }
+    virtual void setOrientation (double roll_deg, double pitch_deg, double heading_deg);
+
+
+    //////////////////////////////////////////////////////////////////////
+    // Part 3: output vectors and matrices in FlightGear coordinates.
+    //////////////////////////////////////////////////////////////////////
+
+    // Vectors and positions...
+
+    // Get zero view_pos
+    virtual float * get_view_pos() { return _relative_view_pos; }
+    // Get the absolute view position in fgfs coordinates.
+    virtual double * get_absolute_view_pos( const Point3D scenery_center );
+    // Get zero elev
+    virtual float * get_zero_elev() { return _zero_elev_view_pos; }
+    // Get world up vector
+    virtual float *get_world_up() { return _world_up; }
+    // Get the relative (to scenery center) view position in fgfs coordinates.
+    virtual float * getRelativeViewPos( const Point3D scenery_center );
+    // Get the absolute zero-elevation view position in fgfs coordinates.
+    virtual float * getZeroElevViewPos( const Point3D scenery_center );
+    // Get surface east vector
+    virtual float *get_surface_east() {	return _surface_east; }
+    // Get surface south vector
+    virtual float *get_surface_south() { return _surface_south; }
+    // Elevation of ground under location (based on scenery output)...
+    void set_cur_elev_m ( double elev ) { _cur_elev_m = elev; }
+    inline double get_cur_elev_m () { return _cur_elev_m; }
+    // Interface to current buckets for use with tilemgr...
+    void set_tile_center ( Point3D tile_center ) { _tile_center = tile_center; }
+    inline Point3D get_tile_center () { return _tile_center; }
+
+    // Matrices...
+    virtual const sgVec4 *getTransformMatrix( const Point3D scenery_center ) {
+        if ( _dirty ) {
+            recalc( scenery_center );
+        }
+	return TRANS;
+    }
+    virtual const sgVec4 *getCachedTransformMatrix() { return TRANS; }
+    virtual const sgVec4 *getUpMatrix( const Point3D scenery_center )  {
+        if ( _dirty ) {
+            recalc( scenery_center );
+        }
+	return UP;
+    }
+    virtual const sgVec4 *getCachedUpMatrix() { return UP; }
+
+
+private:
+
+    //////////////////////////////////////////////////////////////////
+    // private data                                                 //
+    //////////////////////////////////////////////////////////////////
+
+    // flag forcing a recalc of derived view parameters
+    bool _dirty;
+
+    mutable sgdVec3 _absolute_view_pos;
+    mutable sgVec3 _relative_view_pos;
+    mutable sgVec3 _zero_elev_view_pos;
+
+    double _lon_deg;
+    double _lat_deg;
+    double _alt_ft;
+
+    double _roll_deg;
+    double _pitch_deg;
+    double _heading_deg;
+
+    // elevation of ground under this location...
+    double _cur_elev_m;
+    Point3D _tile_center;
+
+    // surface vector heading south
+    sgVec3 _surface_south;
+
+    // surface vector heading east (used to unambiguously align sky
+    // with sun)
+    sgVec3 _surface_east;
+
+    // world up vector (normal to the plane tangent to the earth's
+    // surface at the spot we are directly above
+    sgVec3 _world_up;
+
+    // sg versions of our friendly matrices
+    sgMat4 TRANS, UP;
+
+    //////////////////////////////////////////////////////////////////
+    // private functions                                            //
+    //////////////////////////////////////////////////////////////////
+
+    void recalc( const Point3D scenery_center );
+    void recalcPosition( double lon_deg, double lat_deg, double alt_ft,
+                         const Point3D scenery_center ) const;
+
+    inline void set_dirty() { _dirty = true; }
+    inline void set_clean() { _dirty = false; }
+
+};
+
+
+#endif // _SG_LOCATION_HXX

simgear/scene/model/model.cxx

@@ -0,0 +1,263 @@
+// model.cxx - manage a 3D aircraft model.
+// Written by David Megginson, started 2002.
+//
+// This file is in the Public Domain, and comes with no warranty.
+
+#ifdef HAVE_CONFIG_H
+#include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include <string.h>             // for strcmp()
+
+#include <vector>
+
+#include <plib/sg.h>
+#include <plib/ssg.h>
+#include <plib/ul.h>
+
+#include <simgear/misc/exception.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/props/props.hxx>
+#include <simgear/props/props_io.hxx>
+
+#include "animation.hxx"
+
+#include "model.hxx"
+
+SG_USING_STD(vector);
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Static utility functions.
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Callback to update an animation.
+ */
+static int
+animation_callback (ssgEntity * entity, int mask)
+{
+    ((SGAnimation *)entity->getUserData())->update();
+    return true;
+}
+
+
+/**
+ * Locate a named SSG node in a branch.
+ */
+static ssgEntity *
+find_named_node (ssgEntity * node, const char * name)
+{
+  char * node_name = node->getName();
+  if (node_name != 0 && !strcmp(name, node_name))
+    return node;
+  else if (node->isAKindOf(ssgTypeBranch())) {
+    int nKids = node->getNumKids();
+    for (int i = 0; i < nKids; i++) {
+      ssgEntity * result =
+        find_named_node(((ssgBranch*)node)->getKid(i), name);
+      if (result != 0)
+        return result;
+    }
+  } 
+  return 0;
+}
+
+/**
+ * Splice a branch in between all child nodes and their parents.
+ */
+static void
+splice_branch (ssgBranch * branch, ssgEntity * child)
+{
+  int nParents = child->getNumParents();
+  branch->addKid(child);
+  for (int i = 0; i < nParents; i++) {
+    ssgBranch * parent = child->getParent(i);
+    parent->replaceKid(child, branch);
+  }
+}
+
+/**
+ * Make an offset matrix from rotations and position offset.
+ */
+void
+sgMakeOffsetsMatrix( sgMat4 * result, double h_rot, double p_rot, double r_rot,
+                     double x_off, double y_off, double z_off )
+{
+  sgMat4 rot_matrix;
+  sgMat4 pos_matrix;
+  sgMakeRotMat4(rot_matrix, h_rot, p_rot, r_rot);
+  sgMakeTransMat4(pos_matrix, x_off, y_off, z_off);
+  sgMultMat4(*result, pos_matrix, rot_matrix);
+}
+
+
+void
+sgMakeAnimation( ssgBranch * model,
+                 const char * name,
+                 vector<SGPropertyNode_ptr> &name_nodes,
+                 SGPropertyNode *prop_root,
+                 SGPropertyNode_ptr node,
+                 double sim_time_sec )
+{
+  SGAnimation * animation = 0;
+  const char * type = node->getStringValue("type", "none");
+  if (!strcmp("none", type)) {
+    animation = new SGNullAnimation(node);
+  } else if (!strcmp("range", type)) {
+    animation = new SGRangeAnimation(node);
+  } else if (!strcmp("billboard", type)) {
+    animation = new SGBillboardAnimation(node);
+  } else if (!strcmp("select", type)) {
+    animation = new SGSelectAnimation(prop_root, node);
+  } else if (!strcmp("spin", type)) {
+    animation = new SGSpinAnimation(prop_root, node, sim_time_sec );
+  } else if (!strcmp("timed", type)) {
+    animation = new SGTimedAnimation(node);
+  } else if (!strcmp("rotate", type)) {
+    animation = new SGRotateAnimation(prop_root, node);
+  } else if (!strcmp("translate", type)) {
+    animation = new SGTranslateAnimation(prop_root, node);
+  } else {
+    animation = new SGNullAnimation(node);
+    SG_LOG(SG_INPUT, SG_WARN, "Unknown animation type " << type);
+  }
+
+  if (name != 0)
+      animation->setName((char *)name);
+
+  ssgEntity * object;
+  if (name_nodes.size() > 0) {
+    object = find_named_node(model, name_nodes[0]->getStringValue());
+    if (object == 0) {
+      SG_LOG(SG_INPUT, SG_WARN, "Object " << name_nodes[0]->getStringValue()
+             << " not found");
+      delete animation;
+      animation = 0;
+    }
+  } else {
+    object = model;
+  }
+  
+  ssgBranch * branch = animation->getBranch();
+  splice_branch(branch, object);
+
+  for (unsigned int i = 1; i < name_nodes.size(); i++) {
+      const char * name = name_nodes[i]->getStringValue();
+      object = find_named_node(model, name);
+      if (object == 0) {
+          SG_LOG(SG_INPUT, SG_WARN, "Object " << name << " not found");
+          delete animation;
+          animation = 0;
+      }
+      ssgBranch * oldParent = object->getParent(0);
+      branch->addKid(object);
+      oldParent->removeKid(object);
+  }
+
+  animation->init();
+  branch->setUserData(animation);
+  branch->setTravCallback(SSG_CALLBACK_PRETRAV, animation_callback);
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Global functions.
+////////////////////////////////////////////////////////////////////////
+
+ssgBranch *
+sgLoad3DModel( const string &fg_root, const string &path,
+               SGPropertyNode *prop_root,
+               double sim_time_sec )
+{
+  ssgBranch * model = 0;
+  SGPropertyNode props;
+
+                                // Load the 3D aircraft object itself
+  SGPath xmlpath;
+  SGPath modelpath = path;
+  if ( ulIsAbsolutePathName( path.c_str() ) ) {
+    xmlpath = modelpath;
+  }
+  else {
+    xmlpath = fg_root;
+    xmlpath.append(modelpath.str());
+  }
+
+                                // Check for an XML wrapper
+  if (xmlpath.str().substr(xmlpath.str().size() - 4, 4) == ".xml") {
+    readProperties(xmlpath.str(), &props);
+    if (props.hasValue("/path")) {
+      modelpath = modelpath.dir();
+      modelpath.append(props.getStringValue("/path"));
+    } else {
+      if (model == 0)
+        model = new ssgBranch;
+    }
+  }
+
+                                // Assume that textures are in
+                                // the same location as the XML file.
+  if (model == 0) {
+    ssgTexturePath((char *)xmlpath.dir().c_str());
+    model = (ssgBranch *)ssgLoad((char *)modelpath.c_str());
+    if (model == 0)
+      throw sg_exception("Failed to load 3D model");
+  }
+
+                                // Set up the alignment node
+  ssgTransform * alignmainmodel = new ssgTransform;
+  alignmainmodel->addKid(model);
+  sgMat4 res_matrix;
+  sgMakeOffsetsMatrix(&res_matrix,
+                      props.getFloatValue("/offsets/heading-deg", 0.0),
+                      props.getFloatValue("/offsets/roll-deg", 0.0),
+                      props.getFloatValue("/offsets/pitch-deg", 0.0),
+                      props.getFloatValue("/offsets/x-m", 0.0),
+                      props.getFloatValue("/offsets/y-m", 0.0),
+                      props.getFloatValue("/offsets/z-m", 0.0));
+  alignmainmodel->setTransform(res_matrix);
+
+  unsigned int i;
+
+                                // Load animations
+  vector<SGPropertyNode_ptr> animation_nodes = props.getChildren("animation");
+  for (i = 0; i < animation_nodes.size(); i++) {
+    const char * name = animation_nodes[i]->getStringValue("name", 0);
+    vector<SGPropertyNode_ptr> name_nodes =
+      animation_nodes[i]->getChildren("object-name");
+    sgMakeAnimation( model, name, name_nodes, prop_root, animation_nodes[i],
+                     sim_time_sec);
+  }
+
+                                // Load sub-models
+  vector<SGPropertyNode_ptr> model_nodes = props.getChildren("model");
+  for (i = 0; i < model_nodes.size(); i++) {
+    SGPropertyNode_ptr node = model_nodes[i];
+    ssgTransform * align = new ssgTransform;
+    sgMat4 res_matrix;
+    sgMakeOffsetsMatrix(&res_matrix,
+                        node->getFloatValue("offsets/heading-deg", 0.0),
+                        node->getFloatValue("offsets/roll-deg", 0.0),
+                        node->getFloatValue("offsets/pitch-deg", 0.0),
+                        node->getFloatValue("offsets/x-m", 0.0),
+                        node->getFloatValue("offsets/y-m", 0.0),
+                        node->getFloatValue("offsets/z-m", 0.0));
+    align->setTransform(res_matrix);
+
+    ssgBranch * kid = sgLoad3DModel( fg_root, node->getStringValue("path"),
+                                     prop_root, sim_time_sec );
+    align->addKid(kid);
+    model->addKid(align);
+  }
+
+  return alignmainmodel;
+}
+
+
+// end of model.cxx

simgear/scene/model/model.hxx

@@ -0,0 +1,68 @@
+// model.hxx - manage a 3D aircraft model.
+// Written by David Megginson, started 2002.
+//
+// This file is in the Public Domain, and comes with no warranty.
+
+#ifndef __MODEL_HXX
+#define __MODEL_HXX 1
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+#include <vector>
+
+SG_USING_STD(vector);
+
+#include <plib/sg.h>
+#include <plib/ssg.h>
+
+#include <simgear/props/props.hxx>
+
+
+// Has anyone done anything *really* stupid, like making min and max macros?
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
+
+
+/**
+ * Load a 3D model with or without XML wrapper.  Note, this version
+ * Does not know about or load the panel/cockpit information.  Use the
+ * "model_panel.hxx" version if you want to load an aircraft
+ * (i.e. ownship) with a panel.
+ *
+ * If the path ends in ".xml", then it will be used as a property-
+ * list wrapper to add animations to the model.
+ *
+ * Subsystems should not normally invoke this function directly;
+ * instead, they should use the FGModelLoader declared in loader.hxx.
+ */
+ssgBranch *
+sgLoad3DModel( const string& fg_root, const string &path,
+                          SGPropertyNode *prop_root, double sim_time_sec );
+
+
+/**
+ * Make an offset matrix from rotations and position offset.
+ */
+void
+sgMakeOffsetsMatrix( sgMat4 * result, double h_rot, double p_rot, double r_rot,
+                     double x_off, double y_off, double z_off );
+
+/**
+ * Make the animation
+ */
+void
+sgMakeAnimation( ssgBranch * model,
+                 const char * name,
+                 vector<SGPropertyNode_ptr> &name_nodes,
+                 SGPropertyNode *prop_root,
+                 SGPropertyNode_ptr node,
+                 double sim_time_sec );
+
+
+#endif // __MODEL_HXX

simgear/scene/model/modellib.cxx

@@ -0,0 +1,85 @@
+// modellib.cxx - implement an SSG model library.
+
+#include <simgear/compiler.h>
+#include <simgear/props/props.hxx>
+
+#include "model.hxx"
+
+#include "modellib.hxx"
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of SGModelLib.
+////////////////////////////////////////////////////////////////////////
+
+SGModelLib::SGModelLib ()
+{
+}
+
+SGModelLib::~SGModelLib ()
+{
+    map<string, ssgBase *>::iterator it = _table.begin();
+    while (it != _table.end()) {
+        it->second->deRef();
+        _table.erase(it);
+    }
+}
+
+void
+SGModelLib::flush1()
+{
+    // This routine is disabled because I believe I see multiple
+    // problems with it.
+    //
+    // 1. It blindly deletes all managed models that aren't used
+    //    elsewhere.  Is this what we really want????  In the one
+    //    FlightGear case that calls this method, this clearly is not the
+    //    intention.  I believe it makes more sense to simply leave items
+    //    in the lbrary, even if they are not currently used, they will be
+    //    there already when/if we want to use them later.
+    //
+    // 2. This routine only does a deRef() on the model.  This doesn't actually
+    //    delete the ssg tree so there is a memory leak.
+
+    SG_LOG( SG_GENERAL, SG_ALERT,
+            "WARNGING: a disabled/broken routine has been called.  This should be fixed!" );
+
+    return;
+
+    map<string, ssgBase *>::iterator it = _table.begin();
+    while (it != _table.end()) {
+        ssgBase *item = it->second;
+                                // If there is only one reference, it's
+                                // ours; no one else is using the item.
+        if (item->getRef() == 1) {
+            item->deRef();
+            _table.erase(it);
+        }
+        it++;
+    }
+}
+
+
+ssgEntity *
+SGModelLib::load_model( const string &fg_root,
+                           const string &path,
+                           SGPropertyNode *prop_root,
+                           double sim_time_sec )
+{
+                                // FIXME: normalize path to
+                                // avoid duplicates.
+    map<string, ssgBase *>::iterator it = _table.find(path);
+    if (it == _table.end()) {
+        ssgEntity *model = sgLoad3DModel( fg_root, path, prop_root,
+                                          sim_time_sec );
+        model->ref();
+        _table[path] = model;      // add one reference to keep it around
+        return model;
+    } else {
+        return (ssgEntity *)it->second;
+    }
+}
+
+
+// end of modellib.cxx

simgear/scene/model/modellib.hxx

@@ -0,0 +1,45 @@
+// modellib.cxx - implement an SSG model library.
+
+#ifndef _SG_MODEL_LIB_HXX
+#define _SG_MODEL_LIB_HXX 1
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+#include <simgear/compiler.h>	// for SG_USING_STD
+
+#include <map>
+#include STL_STRING
+
+#include <plib/ssg.h>
+
+#include <simgear/props/props.hxx>
+
+SG_USING_STD(map);
+SG_USING_STD(string);
+
+
+/**
+ * Class for loading and managing models with XML wrappers.
+ */
+class SGModelLib
+{
+
+public:
+
+    SGModelLib ();
+    virtual ~SGModelLib ();
+    virtual void flush1();
+
+    virtual ssgEntity *load_model( const string &fg_root,
+                                   const string &path,
+                                   SGPropertyNode *prop_root,
+                                   double sim_time_sec );
+protected:
+
+    map<string,ssgBase *> _table;
+};
+
+
+#endif // _SG_MODEL_LIB_HXX