Merge branch 'ehofman/sound'

test for an AL or ALC error before calling an ALUT function.
2010-01-16 23:49:36 +01:00 · 2010-01-16 15:50:29 +01:00 · 2010-01-13 07:57:35 +01:00 · 2010-01-13 07:57:30 +01:00 · 2010-01-11 07:15:11 +01:00 · 2010-01-11 07:14:51 +01:00
621 changed files with 104631 additions and 25746 deletions
@@ -0,0 +1,19 @@
 Makefile
 Makefile.in
 SimGear.spec
 aclocal.m4
 autom4te.cache
 config.cache
 config.log
 config.status
 configure
 do-config.sh
 .cdtproject
 .project
 config.guess
 config.sub
 depcomp
 INSTALL
 install-sh
 missing
 mkinstalldirs
@@ -0,0 +1 @@
 Curtis Olsen and others.
@@ -0,0 +1,481 @@
                  GNU LIBRARY GENERAL PUBLIC LICENSE
                       Version 2, June 1991
 Copyright (C) 1991 Free Software Foundation, Inc.
                    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 [This is the first released version of the library GPL.  It is
 numbered 2 because it goes with version 2 of the ordinary GPL.]
                            Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 Licenses are intended to guarantee your freedom to share and change
 free software--to make sure the software is free for all its users.
  This license, the Library General Public License, applies to some
 specially designated Free Software Foundation software, and to any
 other libraries whose authors decide to use it.  You can use it for
 your libraries, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if
 you distribute copies of the library, or if you modify it.
  For example, if you distribute copies of the library, whether gratis
 or for a fee, you must give the recipients all the rights that we gave
 you.  You must make sure that they, too, receive or can get the source
 code.  If you link a program with the library, you must provide
 complete object files to the recipients so that they can relink them
 with the library, after making changes to the library and recompiling
 it.  And you must show them these terms so they know their rights.
  Our method of protecting your rights has two steps: (1) copyright
 the library, and (2) offer you this license which gives you legal
 permission to copy, distribute and/or modify the library.
  Also, for each distributor's protection, we want to make certain
 that everyone understands that there is no warranty for this free
 library.  If the library is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original
 version, so that any problems introduced by others will not reflect on
 the original authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that companies distributing free
 software will individually obtain patent licenses, thus in effect
 transforming the program into proprietary software.  To prevent this,
 we have made it clear that any patent must be licensed for everyone's
 free use or not licensed at all.
  Most GNU software, including some libraries, is covered by the ordinary
 GNU General Public License, which was designed for utility programs.  This
 license, the GNU Library General Public License, applies to certain
 designated libraries.  This license is quite different from the ordinary
 one; be sure to read it in full, and don't assume that anything in it is
 the same as in the ordinary license.
  The reason we have a separate public license for some libraries is that
 they blur the distinction we usually make between modifying or adding to a
 program and simply using it.  Linking a program with a library, without
 changing the library, is in some sense simply using the library, and is
 analogous to running a utility program or application program.  However, in
 a textual and legal sense, the linked executable is a combined work, a
 derivative of the original library, and the ordinary General Public License
 treats it as such.
  Because of this blurred distinction, using the ordinary General
 Public License for libraries did not effectively promote software
 sharing, because most developers did not use the libraries.  We
 concluded that weaker conditions might promote sharing better.
  However, unrestricted linking of non-free programs would deprive the
 users of those programs of all benefit from the free status of the
 libraries themselves.  This Library General Public License is intended to
 permit developers of non-free programs to use free libraries, while
 preserving your freedom as a user of such programs to change the free
 libraries that are incorporated in them.  (We have not seen how to achieve
 this as regards changes in header files, but we have achieved it as regards
 changes in the actual functions of the Library.)  The hope is that this
 will lead to faster development of free libraries.
  The precise terms and conditions for copying, distribution and
 modification follow.  Pay close attention to the difference between a
 "work based on the library" and a "work that uses the library".  The
 former contains code derived from the library, while the latter only
 works together with the library.
  Note that it is possible for a library to be covered by the ordinary
 General Public License rather than by this special one.
                  GNU LIBRARY GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License Agreement applies to any software library which
 contains a notice placed by the copyright holder or other authorized
 party saying it may be distributed under the terms of this Library
 General Public License (also called "this License").  Each licensee is
 addressed as "you".
  A "library" means a collection of software functions and/or data
 prepared so as to be conveniently linked with application programs
 (which use some of those functions and data) to form executables.
  The "Library", below, refers to any such software library or work
 which has been distributed under these terms.  A "work based on the
 Library" means either the Library or any derivative work under
 copyright law: that is to say, a work containing the Library or a
 portion of it, either verbatim or with modifications and/or translated
 straightforwardly into another language.  (Hereinafter, translation is
 included without limitation in the term "modification".)
  "Source code" for a work means the preferred form of the work for
 making modifications to it.  For a library, complete source code means
 all the source code for all modules it contains, plus any associated
 interface definition files, plus the scripts used to control compilation
 and installation of the library.
  Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running a program using the Library is not restricted, and output from
 such a program is covered only if its contents constitute a work based
 on the Library (independent of the use of the Library in a tool for
 writing it).  Whether that is true depends on what the Library does
 and what the program that uses the Library does.
  1. You may copy and distribute verbatim copies of the Library's
 complete source code as you receive it, in any medium, provided that
 you conspicuously and appropriately publish on each copy an
 appropriate copyright notice and disclaimer of warranty; keep intact
 all the notices that refer to this License and to the absence of any
 warranty; and distribute a copy of this License along with the
 Library.
  You may charge a fee for the physical act of transferring a copy,
 and you may at your option offer warranty protection in exchange for a
 fee.
  2. You may modify your copy or copies of the Library or any portion
 of it, thus forming a work based on the Library, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) The modified work must itself be a software library.
    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.
    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.
    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.
    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Library,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Library, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote
 it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Library.
 In addition, mere aggregation of another work not based on the Library
 with the Library (or with a work based on the Library) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may opt to apply the terms of the ordinary GNU General Public
 License instead of this License to a given copy of the Library.  To do
 this, you must alter all the notices that refer to this License, so
 that they refer to the ordinary GNU General Public License, version 2,
 instead of to this License.  (If a newer version than version 2 of the
 ordinary GNU General Public License has appeared, then you can specify
 that version instead if you wish.)  Do not make any other change in
 these notices.
  Once this change is made in a given copy, it is irreversible for
 that copy, so the ordinary GNU General Public License applies to all
 subsequent copies and derivative works made from that copy.
  This option is useful when you wish to copy part of the code of
 the Library into a program that is not a library.
  4. You may copy and distribute the Library (or a portion or
 derivative of it, under Section 2) in object code or executable form
 under the terms of Sections 1 and 2 above provided that you accompany
 it with the complete corresponding machine-readable source code, which
 must be distributed under the terms of Sections 1 and 2 above on a
 medium customarily used for software interchange.
  If distribution of object code is made by offering access to copy
 from a designated place, then offering equivalent access to copy the
 source code from the same place satisfies the requirement to
 distribute the source code, even though third parties are not
 compelled to copy the source along with the object code.
  5. A program that contains no derivative of any portion of the
 Library, but is designed to work with the Library by being compiled or
 linked with it, is called a "work that uses the Library".  Such a
 work, in isolation, is not a derivative work of the Library, and
 therefore falls outside the scope of this License.
  However, linking a "work that uses the Library" with the Library
 creates an executable that is a derivative of the Library (because it
 contains portions of the Library), rather than a "work that uses the
 library".  The executable is therefore covered by this License.
 Section 6 states terms for distribution of such executables.
  When a "work that uses the Library" uses material from a header file
 that is part of the Library, the object code for the work may be a
 derivative work of the Library even though the source code is not.
 Whether this is true is especially significant if the work can be
 linked without the Library, or if the work is itself a library.  The
 threshold for this to be true is not precisely defined by law.
  If such an object file uses only numerical parameters, data
 structure layouts and accessors, and small macros and small inline
 functions (ten lines or less in length), then the use of the object
 file is unrestricted, regardless of whether it is legally a derivative
 work.  (Executables containing this object code plus portions of the
 Library will still fall under Section 6.)
  Otherwise, if the work is a derivative of the Library, you may
 distribute the object code for the work under the terms of Section 6.
 Any executables containing that work also fall under Section 6,
 whether or not they are linked directly with the Library itself.
  6. As an exception to the Sections above, you may also compile or
 link a "work that uses the Library" with the Library to produce a
 work containing portions of the Library, and distribute that work
 under terms of your choice, provided that the terms permit
 modification of the work for the customer's own use and reverse
 engineering for debugging such modifications.
  You must give prominent notice with each copy of the work that the
 Library is used in it and that the Library and its use are covered by
 this License.  You must supply a copy of this License.  If the work
 during execution displays copyright notices, you must include the
 copyright notice for the Library among them, as well as a reference
 directing the user to the copy of this License.  Also, you must do one
 of these things:
    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)
    b) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.
    c) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.
    d) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.
  For an executable, the required form of the "work that uses the
 Library" must include any data and utility programs needed for
 reproducing the executable from it.  However, as a special exception,
 the source code distributed need not include anything that is normally
 distributed (in either source or binary form) with the major
 components (compiler, kernel, and so on) of the operating system on
 which the executable runs, unless that component itself accompanies
 the executable.
  It may happen that this requirement contradicts the license
 restrictions of other proprietary libraries that do not normally
 accompany the operating system.  Such a contradiction means you cannot
 use both them and the Library together in an executable that you
 distribute.
  7. You may place library facilities that are a work based on the
 Library side-by-side in a single library together with other library
 facilities not covered by this License, and distribute such a combined
 library, provided that the separate distribution of the work based on
 the Library and of the other library facilities is otherwise
 permitted, and provided that you do these two things:
    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.
    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.
  8. You may not copy, modify, sublicense, link with, or distribute
 the Library except as expressly provided under this License.  Any
 attempt otherwise to copy, modify, sublicense, link with, or
 distribute the Library is void, and will automatically terminate your
 rights under this License.  However, parties who have received copies,
 or rights, from you under this License will not have their licenses
 terminated so long as such parties remain in full compliance.
  9. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Library or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Library (or any work based on the
 Library), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Library or works based on it.
  10. Each time you redistribute the Library (or any work based on the
 Library), the recipient automatically receives a license from the
 original licensor to copy, distribute, link with or modify the Library
 subject to these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  11. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Library at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Library by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Library.
 If any portion of this section is held invalid or unenforceable under any
 particular circumstance, the balance of the section is intended to apply,
 and the section as a whole is intended to apply in other circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  12. If the distribution and/or use of the Library is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Library under this License may add
 an explicit geographical distribution limitation excluding those countries,
 so that distribution is permitted only in or among countries not thus
 excluded.  In such case, this License incorporates the limitation as if
 written in the body of this License.
  13. The Free Software Foundation may publish revised and/or new
 versions of the Library General Public License from time to time.
 Such new versions will be similar in spirit to the present version,
 but may differ in detail to address new problems or concerns.
 Each version is given a distinguishing version number.  If the Library
 specifies a version number of this License which applies to it and
 "any later version", you have the option of following the terms and
 conditions either of that version or of any later version published by
 the Free Software Foundation.  If the Library does not specify a
 license version number, you may choose any version ever published by
 the Free Software Foundation.
  14. If you wish to incorporate parts of the Library into other free
 programs whose distribution conditions are incompatible with these,
 write to the author to ask for permission.  For software which is
 copyrighted by the Free Software Foundation, write to the Free
 Software Foundation; we sometimes make exceptions for this.  Our
 decision will be guided by the two goals of preserving the free status
 of all derivatives of our free software and of promoting the sharing
 and reuse of software generally.
                            NO WARRANTY
  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
 WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
 EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
 OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
 KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
 LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
 THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
 WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
 AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
 FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
 CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
 LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGES.
                     END OF TERMS AND CONDITIONS
           How to Apply These Terms to Your New Libraries
  If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change.  You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
  To apply these terms, attach the following notices to the library.  It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
    <one line to give the library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
    This library 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
    Library General Public License for more details.
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Also add information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
  <signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice
 That's all there is to it!
@@ -0,0 +1,811 @@
 # Doxyfile 1.2.6
 # This file describes the settings to be used by doxygen for a project
 #
 # All text after a hash (#) is considered a comment and will be ignored
 # The format is:
 #       TAG = value [value, ...]
 # For lists items can also be appended using:
 #       TAG += value [value, ...]
 # Values that contain spaces should be placed between quotes (" ")
 #---------------------------------------------------------------------------
 # General configuration options
 #---------------------------------------------------------------------------
 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
 # by quotes) that should identify the project. 
 PROJECT_NAME           = SimGear
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. 
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 PROJECT_NUMBER         = 1.9.0
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 
 # If a relative path is entered, it will be relative to the location 
 # where doxygen was started. If left blank the current directory will be used.
 OUTPUT_DIRECTORY       = ../doxy
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all 
 # documentation generated by doxygen is written. Doxygen will use this 
 # information to generate all constant output in the proper language. 
 # The default language is English, other supported languages are: 
 # Dutch, French, Italian, Czech, Swedish, German, Finnish, Japanese, 
 # Korean, Hungarian, Norwegian, Spanish, Romanian, Russian, Croatian, 
 # Polish, Portuguese and Slovene.
 OUTPUT_LANGUAGE        = English
 # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
 # documentation are documented, even if no documentation was available. 
 # Private class members and static file members will be hidden unless 
 # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES 
 EXTRACT_ALL            = NO
 # If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
 # will be included in the documentation. 
 EXTRACT_PRIVATE        = NO
 # If the EXTRACT_STATIC tag is set to YES all static members of a file 
 # will be included in the documentation. 
 EXTRACT_STATIC         = NO
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
 # undocumented members of documented classes, files or namespaces. 
 # If set to NO (the default) these members will be included in the 
 # various overviews, but no documentation section is generated. 
 # This option has no effect if EXTRACT_ALL is enabled. 
 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     = 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 
 # the file and class documentation (similar to JavaDoc). 
 # Set to NO to disable this. 
 BRIEF_MEMBER_DESC      = YES
 # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
 # the brief description of a member or function before the detailed description. 
 # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
 # brief descriptions will be completely suppressed. 
 REPEAT_BRIEF           = YES
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
 # Doxygen will generate a detailed section even if there is only a brief 
 # description. 
 ALWAYS_DETAILED_SEC    = NO
 # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
 # path before files name in the file list and in the header files. If set 
 # to NO the shortest path that makes the file name unique will be used. 
 FULL_PATH_NAMES        = NO
 # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
 # can be used to strip a user defined part of the path. Stripping is 
 # only done if one of the specified strings matches the left-hand part of 
 # the path. It is allowed to use relative paths in the argument list.
 STRIP_FROM_PATH        = 
 # The INTERNAL_DOCS tag determines if documentation 
 # that is typed after a \internal command is included. If the tag is set 
 # to NO (the default) then the documentation will be excluded. 
 # Set it to YES to include the internal documentation. 
 INTERNAL_DOCS          = NO
 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
 # generate a class diagram (in Html and LaTeX) for classes with base or 
 # super classes. Setting the tag to NO turns the diagrams off. 
 CLASS_DIAGRAMS         = YES
 # If the SOURCE_BROWSER tag is set to YES then a list of source files will 
 # be generated. Documented entities will be cross-referenced with these sources. 
 SOURCE_BROWSER         = YES
 # Setting the INLINE_SOURCES tag to YES will include the body 
 # of functions and classes directly in the documentation. 
 INLINE_SOURCES         = NO
 # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
 # doxygen to hide any special comment blocks from generated source code 
 # fragments. Normal C and C++ comments will always remain visible. 
 STRIP_CODE_COMMENTS    = YES
 # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
 # file names in lower case letters. If set to YES upper case letters are also 
 # allowed. This is useful if you have classes or files whose names only differ 
 # in case and if your file system supports case sensitive file names. Windows 
 # users are adviced to set this option to NO.
 CASE_SENSE_NAMES       = YES
 # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
 # will show members with their full class and namespace scopes in the 
 # documentation. If set to YES the scope will be hidden. 
 HIDE_SCOPE_NAMES       = NO
 # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
 # will generate a verbatim copy of the header file for each class for 
 # which an include is specified. Set to NO to disable this. 
 VERBATIM_HEADERS       = YES
 # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
 # will put list of the files that are included by a file in the documentation 
 # of that file. 
 SHOW_INCLUDE_FILES     = YES
 # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
 # will interpret the first line (until the first dot) of a JavaDoc-style 
 # comment as the brief description. If set to NO, the JavaDoc 
 # comments  will behave just like the Qt-style comments (thus requiring an 
 # explict @brief command for a brief description. 
 JAVADOC_AUTOBRIEF      = YES
 # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
 # member inherits the documentation from any documented member that it 
 # reimplements. 
 INHERIT_DOCS           = YES
 # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
 # is inserted in the documentation for inline members. 
 INLINE_INFO            = YES
 # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
 # will sort the (detailed) documentation of file and class members 
 # alphabetically by member name. If set to NO the members will appear in 
 # declaration order. 
 SORT_MEMBER_DOCS       = YES
 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
 # tag is set to YES, then doxygen will reuse the documentation of the first 
 # member in the group (if any) for the other members of the group. By default 
 # all members of a group must be documented explicitly.
 DISTRIBUTE_GROUP_DOC   = NO
 # The TAB_SIZE tag can be used to set the number of spaces in a tab. 
 # Doxygen uses this value to replace tabs by spaces in code fragments. 
 TAB_SIZE               = 8
 # The ENABLE_SECTIONS tag can be used to enable conditional 
 # documentation sections, marked by \if sectionname ... \endif. 
 ENABLED_SECTIONS       = 
 # The GENERATE_TODOLIST tag can be used to enable (YES) or 
 # disable (NO) the todo list. This list is created by putting \todo 
 # commands in the documentation.
 GENERATE_TODOLIST      = YES
 # The GENERATE_TESTLIST tag can be used to enable (YES) or 
 # disable (NO) the test list. This list is created by putting \test 
 # commands in the documentation.
 GENERATE_TESTLIST      = YES
 # The GENERATE_BUGLIST tag can be used to enable (YES) or 
 # disable (NO) the bug list. This list is created by putting \bug 
 # commands in the documentation.
 GENERATE_BUGLIST       = YES
 # This tag can be used to specify a number of aliases that acts 
 # as commands in the documentation. An alias has the form "name=value". 
 # For example adding "sideeffect=\par Side Effects:\n" will allow you to 
 # put the command \sideeffect (or @sideeffect) in the documentation, which 
 # will result in a user defined paragraph with heading "Side Effects:". 
 # You can put \n's in the value part of an alias to insert newlines. 
 ALIASES                = 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
 # the initial value of a variable or define consist of for it to appear in 
 # the documentation. If the initializer consists of more lines than specified 
 # here it will be hidden. Use a value of 0 to hide initializers completely. 
 # The appearance of the initializer of individual variables and defines in the 
 # documentation can be controlled using \showinitializer or \hideinitializer 
 # command in the documentation regardless of this setting. 
 MAX_INITIALIZER_LINES  = 30
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources 
 # only. Doxygen will then generate output that is more tailored for C. 
 # For instance some of the names that are used will be different. The list 
 # of all members will be omitted, etc. 
 OPTIMIZE_OUTPUT_FOR_C  = NO
 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
 # at the bottom of the documentation of classes and structs. If set to YES the 
 # list will mention the files that were used to generate the documentation. 
 SHOW_USED_FILES        = YES
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 # The QUIET tag can be used to turn on/off the messages that are generated 
 # by doxygen. Possible values are YES and NO. If left blank NO is used. 
 QUIET                  = NO
 # The WARNINGS tag can be used to turn on/off the warning messages that are 
 # generated by doxygen. Possible values are YES and NO. If left blank 
 # NO is used. 
 WARNINGS               = YES
 # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
 # for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
 # automatically be disabled. 
 WARN_IF_UNDOCUMENTED   = YES
 # The WARN_FORMAT tag determines the format of the warning messages that 
 # doxygen can produce. The string should contain the $file, $line, and $text 
 # tags, which will be replaced by the file and line number from which the 
 # warning originated and the warning text. 
 WARN_FORMAT            = "$file:$line: $text"
 # The WARN_LOGFILE tag can be used to specify a file to which warning 
 # and error messages should be written. If left blank the output is written 
 # to stderr. 
 WARN_LOGFILE           = 
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
 # The INPUT tag can be used to specify the files and/or directories that contain 
 # documented source files. You may enter file names like "myfile.cpp" or 
 # directories like "/usr/src/myproject". Separate the files or directories 
 # with spaces. 
 INPUT                  = \
        DoxygenMain.cxx \
 	simgear/bucket \
 	simgear/compiler.h \
 	simgear/constants.h \
 	simgear/debug \
 	simgear/environment \
 	simgear/ephemeris \
 	simgear/io \
 	simgear/magvar \
 	simgear/math \
 	simgear/misc \
 	simgear/nasal \
        simgear/props \
 	simgear/route \
 	simgear/scene \
 	simgear/screen \
 	simgear/serial \
 	simgear/structure \
 	simgear/sg_inlines.h \
 	simgear/sg_traits.hxx \
        simgear/sound \
 	simgear/threads \
 	simgear/timing \
 	simgear/xml
 # If the value of the INPUT tag contains directories, you can use the 
 # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
 # and *.h) to filter out the source-files in the directories. If left 
 # blank all files are included. 
 FILE_PATTERNS          = *.h *.hxx *.c *.cxx *.cpp
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories 
 # should be searched for input files as well. Possible values are YES and NO. 
 # If left blank NO is used. 
 RECURSIVE              = YES
 # The EXCLUDE tag can be used to specify files and/or directories that should 
 # 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/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 
 # certain files from those directories. 
 EXCLUDE_PATTERNS       = 
 # The EXAMPLE_PATH tag can be used to specify one or more files or 
 # directories that contain example code fragments that are included (see 
 # the \include command). 
 EXAMPLE_PATH           = 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the 
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
 # and *.h) to filter out the source-files in the directories. If left 
 # blank all files are included. 
 EXAMPLE_PATTERNS       = 
 # The IMAGE_PATH tag can be used to specify one or more files or 
 # directories that contain image that are included in the documentation (see 
 # the \image command). 
 IMAGE_PATH             = 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should 
 # invoke to filter for each input file. Doxygen will invoke the filter program 
 # by executing (via popen()) the command <filter> <input-file>, where <filter> 
 # is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
 # input file. Doxygen will then use the output that the filter program writes 
 # to standard output. 
 INPUT_FILTER           = 
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
 # INPUT_FILTER) will be used to filter the input files when producing source 
 # files to browse. 
 FILTER_SOURCE_FILES    = NO
 #---------------------------------------------------------------------------
 # configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
 # of all compounds will be generated. Enable this if the project 
 # contains a lot of classes, structs, unions or interfaces. 
 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 
 # in which this list will be split (can be a number in the range [1..20]) 
 COLS_IN_ALPHA_INDEX    = 5
 # In case all classes in a project start with a common prefix, all 
 # classes will be put under the same header in the alphabetical index. 
 # The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
 # should be ignored while generating the index headers. 
 IGNORE_PREFIX          = 
 #---------------------------------------------------------------------------
 # configuration options related to the HTML output
 #---------------------------------------------------------------------------
 # If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
 # generate HTML output. 
 GENERATE_HTML          = YES
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be 
 # put in front of it. If left blank `html' will be used as the default path. 
 HTML_OUTPUT            = html
 # The HTML_HEADER tag can be used to specify a personal HTML header for 
 # each generated HTML page. If it is left blank doxygen will generate a 
 # standard header.
 HTML_HEADER            = 
 # The HTML_FOOTER tag can be used to specify a personal HTML footer for 
 # each generated HTML page. If it is left blank doxygen will generate a 
 # standard footer.
 HTML_FOOTER            = 
 # The HTML_STYLESHEET tag can be used to specify a user defined cascading 
 # style sheet that is used by each HTML page. It can be used to 
 # fine-tune the look of the HTML output. If the tag is left blank doxygen 
 # will generate a default style sheet 
 HTML_STYLESHEET        = 
 # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
 # files or namespaces will be aligned in HTML using tables. If set to 
 # NO a bullet list will be used. 
 HTML_ALIGN_MEMBERS     = YES
 # If the GENERATE_HTMLHELP tag is set to YES, additional index files 
 # will be generated that can be used as input for tools like the 
 # Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
 # of the generated HTML documentation. 
 GENERATE_HTMLHELP      = NO
 # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
 # controls if a separate .chi index file is generated (YES) or that 
 # it should be included in the master .chm file (NO).
 GENERATE_CHI           = NO
 # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
 # controls whether a binary table of contents is generated (YES) or a 
 # normal table of contents (NO) in the .chm file.
 BINARY_TOC             = NO
 # The TOC_EXPAND flag can be set YES to add extra items for group members 
 # to the contents of the Html help documentation and to the tree view. 
 TOC_EXPAND             = NO
 # The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
 # top of each HTML page. The value NO (the default) enables the index and 
 # the value YES disables it. 
 DISABLE_INDEX          = NO
 # This tag can be used to set the number of enum values (range [1..20]) 
 # that doxygen will group on one line in the generated HTML documentation. 
 ENUM_VALUES_PER_LINE   = 4
 # If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
 # generated containing a tree-like index structure (just like the one that 
 # is generated for HTML Help). For this to work a browser that supports 
 # JavaScript and frames is required (for instance Netscape 4.0+ 
 # or Internet explorer 4.0+). 
 GENERATE_TREEVIEW      = NO
 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
 # used to set the initial width (in pixels) of the frame in which the tree 
 # is shown. 
 TREEVIEW_WIDTH         = 250
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
 # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
 # generate Latex output. 
 GENERATE_LATEX         = YES
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be 
 # put in front of it. If left blank `latex' will be used as the default path. 
 LATEX_OUTPUT           = latex
 # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
 # LaTeX documents. This may be useful for small projects and may help to 
 # save some trees in general. 
 COMPACT_LATEX          = NO
 # The PAPER_TYPE tag can be used to set the paper type that is used 
 # by the printer. Possible values are: a4, a4wide, letter, legal and 
 # executive. If left blank a4wide will be used. 
 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. 
 EXTRA_PACKAGES         = 
 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
 # the generated latex document. The header should contain everything until 
 # the first chapter. If it is left blank doxygen will generate a 
 # standard header. Notice: only use this tag if you know what you are doing! 
 LATEX_HEADER           = 
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
 # is prepared for conversion to pdf (using ps2pdf). The pdf file will 
 # contain links (just like the HTML output) instead of page references 
 # This makes the output suitable for online browsing using a pdf viewer. 
 PDF_HYPERLINKS         = NO
 # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
 # plain latex in the generated Makefile. Set this option to YES to get a 
 # higher quality PDF documentation. 
 USE_PDFLATEX           = NO
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
 # command to the generated LaTeX files. This will instruct LaTeX to keep 
 # running if errors occur, instead of asking the user for help. 
 # This option is also used when generating formulas in HTML. 
 LATEX_BATCHMODE        = NO
 #---------------------------------------------------------------------------
 # configuration options related to the RTF output
 #---------------------------------------------------------------------------
 # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
 # The RTF output is optimised for Word 97 and may not look very pretty with 
 # other RTF readers or editors.
 GENERATE_RTF           = YES
 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be 
 # put in front of it. If left blank `rtf' will be used as the default path. 
 RTF_OUTPUT             = rtf
 # If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
 # RTF documents. This may be useful for small projects and may help to 
 # save some trees in general. 
 COMPACT_RTF            = NO
 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
 # will contain hyperlink fields. The RTF file will 
 # contain links (just like the HTML output) instead of page references. 
 # This makes the output suitable for online browsing using a WORD or other. 
 # programs which support those fields. 
 # Note: wordpad (write) and others do not support links. 
 RTF_HYPERLINKS         = NO
 # Load stylesheet definitions from file. Syntax is similar to doxygen's 
 # config file, i.e. a series of assigments. You only have to provide 
 # replacements, missing definitions are set to their default value. 
 RTF_STYLESHEET_FILE    = 
 #---------------------------------------------------------------------------
 # configuration options related to the man page output
 #---------------------------------------------------------------------------
 # If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
 # generate man pages 
 GENERATE_MAN           = YES
 # The MAN_OUTPUT tag is used to specify where the man pages will be put. 
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be 
 # put in front of it. If left blank `man' will be used as the default path. 
 MAN_OUTPUT             = man
 # The MAN_EXTENSION tag determines the extension that is added to 
 # the generated man pages (default is the subroutine's section .3) 
 MAN_EXTENSION          = .3
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor   
 #---------------------------------------------------------------------------
 # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
 # evaluate all C-preprocessor directives found in the sources and include 
 # files. 
 ENABLE_PREPROCESSING   = YES
 # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
 # names in the source code. If set to NO (the default) only conditional 
 # compilation will be performed. Macro expansion can be done in a controlled 
 # way by setting EXPAND_ONLY_PREDEF to YES. 
 MACRO_EXPANSION        = NO
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
 # then the macro expansion is limited to the macros specified with the 
 # PREDEFINED and EXPAND_AS_PREDEFINED tags. 
 EXPAND_ONLY_PREDEF     = NO
 # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
 # in the INCLUDE_PATH (see below) will be search if a #include is found. 
 SEARCH_INCLUDES        = YES
 # The INCLUDE_PATH tag can be used to specify one or more directories that 
 # contain include files that are not input files but should be processed by 
 # the preprocessor. 
 INCLUDE_PATH           = 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
 # patterns (like *.h and *.hpp) to filter out the header-files in the 
 # directories. If left blank, the patterns specified with FILE_PATTERNS will 
 # be used. 
 INCLUDE_FILE_PATTERNS  = 
 # The PREDEFINED tag can be used to specify one or more macro names that 
 # are defined before the preprocessor is started (similar to the -D option of 
 # gcc). The argument of the tag is a list of macros of the form: name 
 # or name=definition (no spaces). If the definition and the = are 
 # omitted =1 is assumed. 
 PREDEFINED             = 
 # If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then 
 # this tag can be used to specify a list of macro names that should be expanded. 
 # The macro definition that is found in the sources will be used. 
 # Use the PREDEFINED tag if you want to use a different macro definition. 
 EXPAND_AS_DEFINED      = 
 #---------------------------------------------------------------------------
 # Configuration::addtions related to external references   
 #---------------------------------------------------------------------------
 # The TAGFILES tag can be used to specify one or more tagfiles. 
 TAGFILES               = 
 # When a file name is specified after GENERATE_TAGFILE, doxygen will create 
 # a tag file that is based on the input files it reads. 
 GENERATE_TAGFILE       = 
 # If the ALLEXTERNALS tag is set to YES all external classes will be listed 
 # in the class index. If set to NO only the inherited external classes 
 # will be listed. 
 ALLEXTERNALS           = NO
 # The PERL_PATH should be the absolute path and name of the perl script 
 # interpreter (i.e. the result of `which perl'). 
 PERL_PATH              = /usr/bin/perl
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool   
 #---------------------------------------------------------------------------
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
 # available from the path. This tool is part of Graphviz, a graph visualization 
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section 
 # have no effect if this option is set to NO (the default) 
 HAVE_DOT               = NO
 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
 # will generate a graph for each documented class showing the direct and 
 # indirect inheritance relations. Setting this tag to YES will force the 
 # the CLASS_DIAGRAMS tag to NO.
 CLASS_GRAPH            = YES
 # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
 # will generate a graph for each documented class showing the direct and 
 # indirect implementation dependencies (inheritance, containment, and 
 # class references variables) of the class with other documented classes. 
 COLLABORATION_GRAPH    = YES
 # If the ENABLE_PREPROCESSING, INCLUDE_GRAPH, and HAVE_DOT tags are set to 
 # YES then doxygen will generate a graph for each documented file showing 
 # the direct and indirect include dependencies of the file with other 
 # documented files. 
 INCLUDE_GRAPH          = YES
 # If the ENABLE_PREPROCESSING, INCLUDED_BY_GRAPH, and HAVE_DOT tags are set to 
 # YES then doxygen will generate a graph for each documented header file showing 
 # the documented files that directly or indirectly include this file 
 INCLUDED_BY_GRAPH      = YES
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
 # will graphical hierarchy of all classes instead of a textual one. 
 GRAPHICAL_HIERARCHY    = YES
 # The tag DOT_PATH can be used to specify the path where the dot tool can be 
 # found. If left blank, it is assumed the dot tool can be found on the path. 
 DOT_PATH               = 
 # The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
 # (in pixels) of the graphs generated by dot. If a graph becomes larger than 
 # this value, doxygen will try to truncate the graph, so that it fits within 
 # the specified constraint. Beware that most browsers cannot cope with very 
 # large images. 
 MAX_DOT_GRAPH_WIDTH    = 1024
 # The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
 # (in pixels) of the graphs generated by dot. If a graph becomes larger than 
 # this value, doxygen will try to truncate the graph, so that it fits within 
 # the specified constraint. Beware that most browsers cannot cope with very 
 # large images. 
 MAX_DOT_GRAPH_HEIGHT   = 1024
 # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
 # generate a legend page explaining the meaning of the various boxes and 
 # arrows in the dot generated graphs. 
 GENERATE_LEGEND        = YES
 # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
 # remove the intermedate dot files that are used to generate 
 # the various graphs. 
 DOT_CLEANUP            = YES
 #---------------------------------------------------------------------------
 # Configuration::addtions related to the search engine   
 #---------------------------------------------------------------------------
 # The SEARCHENGINE tag specifies whether or not a search engine should be 
 # used. If set to NO the values of all tags below this one will be ignored. 
 SEARCHENGINE           = NO
 # The CGI_NAME tag should be the name of the CGI script that 
 # starts the search engine (doxysearch) with the correct parameters. 
 # A script with this name will be generated by doxygen. 
 CGI_NAME               = search.cgi
 # The CGI_URL tag should be the absolute URL to the directory where the 
 # cgi binaries are located. See the documentation of your http daemon for 
 # details. 
 CGI_URL                = 
 # The DOC_URL tag should be the absolute URL to the directory where the 
 # documentation is located. If left blank the absolute path to the 
 # documentation, with file:// prepended to it, will be used. 
 DOC_URL                = 
 # The DOC_ABSPATH tag should be the absolute path to the directory where the 
 # documentation is located. If left blank the directory on the local machine 
 # will be used. 
 DOC_ABSPATH            = 
 # The BIN_ABSPATH tag must point to the directory where the doxysearch binary 
 # is installed. 
 BIN_ABSPATH            = /usr/local/bin/
 # The EXT_DOC_PATHS tag can be used to specify one or more paths to 
 # documentation generated for other projects. This allows doxysearch to search 
 # the documentation for these projects as well. 
 EXT_DOC_PATHS          = 
@@ -0,0 +1,108 @@
 /* This is a dummy code file that only contains doxygen main page
   documentation.  It has a .cxx extension so that emacs will happily
   autoindent correctly. */
 /** \mainpage SimGear
 * Simulation, Visualization, and Game development libraries.
 * \section intro Introduction
 *
 * SimGear is a collection of libraries which provide a variety of
 * functionality useful for building simulations, visualizations, and
 * even games.  All the SimGear code is designed to be portable across
 * a wide variety of platforms and compilers.  It has primarily been
 * developed in support of the FlightGear project, but as development
 * moves forward, we are generalizing the code to make more of it
 * useful for other types of applications.
 *
 * Some of the functionality provide includes
 *
 * - Compiler and platform abstractions for many tricky differences.
 *   (compiler.h)
 *
 * - A whole earth tiling/indexing scheme.  (SGBucket)
 *
 * - A console debugging output scheme that tracks severity and
 *   category that can be completely compiled out for a final build release.
 *   (logstream.hxx)
 *
 * - Code to manage "real" time (SGTime), time zones (SGTimeZone), and
 *   millesecond time differences (SGTimeStamp).
 *
 * - Code to calculate accurate positions of sun, moon, stars, and
 *   planets for a given time, date, season, earth location, etc.
 *   (SGEphemeris)
 *
 * - Code to render a realistic sky dome, cloud layers, sun, moon,
 *   stars, and planets all with realistic day/night/sunset/sunrise
 *   effects.  Includes things like correct moon phase, textured moon,
 *   sun halo, etc. (SGSky is built on top of SGCloudLayer ...)
 *
 * - Simple serial (SGSerial), file (SGFile), socket (SGSocket), and
 *   UDP socket (SGSocketUDP) I/O abstractions.
 *
 * - Code to calculate magnetic variation. (SGMagVar)
 *
 * - A variety of classes and functions for interpolation tables
 *   (SGInterpTable), least squares computation (leastsqs.hxx), 3D
 *   point/vectors (Point3D), 3D polar math and conversions (polar3d.hxx),
 *   WGS-84 math and conversions (sg_geodesy.hxx), random number abstraction
 *   (sg_random.h), STL conglomerates for common list types (sg_types.hxx),
 *   and other vector and linear algebra routines (vector.hxx)
 *
 * - An abstraction to hide platform dependent path naming schemes. (SGPath)
 *
 * - A C++ streams wrapper to handle compress input/output streams.
 *   (sg_gzifstream)
 *
 * - An optimized "property manager" which associates ascii property
 *   names with their corresponding value.  This can be a great way to build
 *   loose linkages between modules, or build linkages/connections that can
 *   be determined from config files or at runtime.  (SGPropertyNode)
 *   Also included is a set of functions to dump the property tree into a
 *   standard xml file and subsequently read/parse a standard xml file and
 *   rebuild the associated property tree.  (props_io.hxx)
 *
 * - Scene management and drawing routines:
 *   - material property management
 *   - object management
 *   - terrain tile management and paging
 *   - sky dome rendering (with ephemeral objects)
 *
 * - Code to handle screen dumps (screen-dump.hxx) and ultra-hires
 *   tile rendered screen dumps (tr.h)
 *
 * - A sound effects manager.  (SGSoundMgr, SGSimpleSound, SGSound)
 *
 * - A threading abstraction.  (SGThread)
 *
 * - A simple but highly functional XML parser that interfaces nicely
 *   with the property manager.  (easyxml.hxx)
 * \section supports Supported Platforms
 * SimGear has been built on the following platforms:
 *
 *   - Linux (x86)
 *   - Windows (MSVC, Cygwin, Mingwin)
 *   - SGI (native compilers)
 *   - Mac OS X
 *   - FreeBSD
 * \section depends Dependencies
 *
 * SimGear depends on several other open source packages.  These must
 * be installed before SimGear can be installed:
 *
 *   - glut and opengl
 *   - plib (http://plib.sf.net)
 *   - metakit
 *   - zlib
 *   - libjpeg (optional)
 *   - pthread (optional)
 * \section license Licensing
 *
 * SimGear is licensed under the terms of the LGPL
 */
@@ -1,14 +1,25 @@
-EXTRA_DIST	= mksymlinks.sh acsite.m4 acconfig.h
+EXTRA_DIST = \
 	acinclude.m4 \
 	autogen.sh \
 	DoxygenMain.cxx \
 	README.MSVC \
 	README.zlib \
 	README.plib \
 	README.OpenAL \
 	README.OSG \
 	projects \
 	SimGear.dsp \
 	SimGear.dsw
-SUBDIRS		= simgear
+SUBDIRS	= simgear
 dist-hook:
 	(cd $(top_srcdir); $(HOME)/Projects/FlightGear/admin/am2dsp.pl)
 	rm -rf `find $(distdir)/projects -name CVS`
 #
 # Rule to build RPM distribution package
 #
 rpm: dist
-	cp $(PACKAGE)-$(VERSION).tar.gz /usr/src/packages/SOURCES
+	rpm -ta $(PACKAGE)-$(VERSION).tar.gz
 	rpm -ba @PACKAGE@.spec
 dist-hook:
 	tar cf - simgear/metar | (cd $(distdir); tar xvf -)
@@ -1,3 +1,411 @@
 Version 1.9.0
 * Thu Dec 18 15:12:15 CST 2008
 Version 1.8.6
 * Mon Dec  1 14:02:47 CST 2008
 Version 1.8.5
 * October 30, 2008 (source code snapshot release)
 New in 0.3.10
 * April 5, 2006
 * Add a small accessor function to expose local timezone offset.
 * Improved exception handling and made output more helpful in various places.
 * Better pbuffer runtime detection.
 * Add directory creation capability to file/path library.
 * Added a basic reference counting class to improve robustness of
  memory management in places.  Use this for all scenegraph
  references, sgmaterial references, sgmatmodel references, and
  sgsoundsample references.
 * Add support for point sprites.
 * Updates to rain cone rendering.
 * Add a new vector library and integrate that with improved coordinate
  system conversion code.
 * Mutex locking and cleanup improvements in the threading abstraction
  library.
 * Add MacOS RenderTexture support.
 * Add a Nasal based io libarary that is not activated by default.
 * Added a set of MS-VC8 project files.
 * Various platform related bug fixes.
 * Various compiler related bug/warning fixes.
 * Clean up some things that triggered valgrind warnings.
 * Fix a Nasal cmp() bug.
 * Removed ancient version of zlib from distribution.
 New in 0.3.9
 * November 17, 2005
 * Add support for OpenAL 1.1 (with a separate alut library.)
 * Add support for volumetric shadows.  Aircraft can cast shadows on themselves
  as well as onto the ground (by Harald Johnsen.)
 * New 3d volumetric clouds by Harald Johnsen (along with several rounds of
  followup fixes and improvements.)
 * Remove Mark Harris's old 3d clouds because they were never properly
  integrated.  And we now have new 3d clouds.
 * Add support for seasonal textures (with a set of winter textures added
  to FlightGear.)
 * Updated Nasal scripting system.  Adds several new syntax convenience
  features, fixes parser bugs, fixes several internal bugs.
 * Our 3d cockpit jitter problem is fixed (woohoo!)
 * Add code to support rendering to a texture.
 * Allow "tip" popups to pop themselves down after the appropriate
  timeout, even if the sim time is paused.
 * Various low model level animation fixes and additions ... color,
  transparency, 'chrome' effects, randomized spin, etc.
 * Create our own portable stdint.h implementation.
 * Fixed several memory leaks.
 * removeChildren() added to the property system.
 * Fix many cases of 'const'.
 * Fixes for cygwin, solaris/sun, Mac OS X, MSVC, gcc-3.4.x.
 New in 0.3.8
 * January 18, 2005
 * Configure script does a sanity check for the existence of openal.
 * Better pthreads detection for FreeBSD.
 * Abstract out the location of gl.h, glu.h, and glut.h so we can more
  easily support MacOS which puts these in an oddball location.
 * Added two new debug output types for instrumentation and systems.
 * Add a name parameter to the waypoint class for supporting a route
  manager in the flightgear gps module.
 * Make display list usage optional.
 * Event manager: specifying a zero delay will force event execution in
  the next frame rather than entering an infinite loop.
 * gcc-4.0 fix.
 * Fixes to property tree loading and saving.
 * Make volume inaudible at startup.
 * Solaris fixes.
 * For low density cloud coverage, blend the layer to nothing as we pass
  through instead of fully engulfing the aircraft in the cloud.
 * Add several new capabilities to the texture management code for building
  normal maps and doing some simple on-the-fly effects on textures.
 * Better error message for sound problems.
 * Add support for binding a thread to a specific CPU.
 New in 0.3.7
 * October 12, 2004
 * Add support for parsing xml from an in memory buffer, not just a file.
 * Don't reduce visibility for a "clear" cloud layer.
 * Add support for audio orientation (direction and cone) for internal
  view and tower view.
 * Add support for drawing from display lists rather than in immediate mode.
  This provides a big performance improvement on many systems.
 New in 0.3.6
 * July 29, 2004
 * Better MinGW support
 * A bit better handling of OpenAL under Cygwin
 * Switched audio system from plib's "sl/sm" to OpenAL.
 * Add support for scaling an object based on distance.  The scaling
  factor is determined by a lookup table based on distance.
 * Add a "flash" animation type.
 * Fix cloud positioning/animation bugs.
 * Fix an off-by-one error in props_io.cxx
 * Clip audio gain (volume) to 1.0
 New in 0.3.5
 * March 26, 2004
 * Added Andy's nasal interpreter for small built in scripting tasks.
  Nasal integrates nicely with FlightGear's property system.
 * Added new (much simpler) metar parsing code (removed older more
  complex code.)
 * Support VASI/PAPI lights correctly.
 * Fixes to cloud animation.
 * Updates to sky dome coloring as well as sun/moon coloring.
 * Vary environment lighting with visibility (subtlety.)
 * Support control of alpha test in model animation.
 * Complete rewrite of the event manager.
 * Updates to low level socket code to make it more flexible.
 * Win32 serial port communication fixes.
 * sg_geodesy rewritten to be more accurate and robust and symmetric.
 New in 0.3.4
 * October 22, 2003
 * Removed Metakit, FlightGear no longer uses it.
 * Removed all glut dependencies from SimGear.
 * Moved FGEventMgr and FGSubsystemMgr over to SimGear.
 * Some more incremental work on 3D clouds.
 * Added some "fastmath" functions.
 * Some lighting tweaks and fixes (especially for taxiways.)
 * Added support for "blend" and "scale" and "texture" animations.
 * Added support for animating rotations around an arbitrary axis (so the
  aircraft designer isn't forced to figure out animations as a combination
  of rotations around X, Y, and X axes.
 * Updates to sky dome modeling and make cloud layers follow the curve
  of the earth (sort of.)
 * Updates to sky dome, cloud, and sunrise/sunset color and lighting
  effects to make them more realistic and lifelike.
 * Better support for detecting and using OpenGL extensions at run time.
 * Add support for win32-pthreads in MSVC.NET
 * Various MSVC fixes.
 * Various Solaris fixes.
 * Various cygwin/mingwin fixes.
 * Various Mac OS X fixes.
 * Various Irix fixes.
 New in 0.3.3
 * June 3, 2003
 * Fix a compile problem for cygwin
 * Updated/tweaked doxygen documentation in several areas
 New in 0.3.2
 * June 2, 2003
 * Moved quite a bit of low level model management and "state"
  management code from FlightGear into SimGear and did a substantial
  amount of restructuring and dependency clean up in the process.
  Created a "scene" subdirectory with sub-subdirectories for material
  management, basic model and model animation management, sky
  rendering, and low level loaders for the "TerraGear" tile object format.
 * Removed support of the flat shaded and non-textured material
  property variants.  You can still do these things, but extra states
  are no longer set up automatically.
 * Removed 3d clouds from the default build ... these need a maintainer
  or better yet, a complete plib-based rewrite.
 * Moved the FlightGear sound effect manager code over to SimGear.
 * Updated the cloud layer surface to better follow the inverted bowl
  shape.
 * Much work on cloud/sky coloring, and also much work on
  sunset/sunrise coloring.
 * Fixed an obscure bug in cloud texture loading which caused each
  cloud texture to be loaded 5 times.  Ouch!
 * Various class and function renaming to make them better fit into the
  standard SimGear naming scheme.
 * Added some additional convenience functions to the SGPath class.
 * Upgraded the distributed version of metakit.
 * FreeBSD fixes.
 * Irix fixes (better STL/ISO C++ header support.)
 * Mingwin fixes.
 * Better MacOS support
 * MSVC fixes.
 New in 0.3.1
 * December 4, 2002
 * Fix a major packaging blunder with several missing files.
 New in 0.3.0
 * December 3, 2002
 * removed interpreter subdir
 * NOMINAX fix for Cygwin/gcc-3.2
 * Added some prototype 3d clouds based on Mark Harris's demos.
 * Simplified the command manager interface
 * Allow an "include" attribute on root PropertyList element.
 New in 0.2.0
 * September 6, 2002
 * Modernized the autoconf/make scripts, plus lots of tweaks and enhancements.
 * Removed efence support (in favor of valgrind.)
 * Added a javascript interpreter.
 * SGSocket reimplemented on top of plib/net libs.
 * Added a new random number generation algorithm.
 * Total rewrite of the strutils package.
 * Patch for the random number seed.
 * IA-64 w/ Intel compiler fixes.
 * MSVC/MINGW fixes.
 * Mac OS X fixes.
 * Irix fixes.
 * Code clean ups to remove warning messages.
 * Optimizations in sg_binobj to reduce the amount of memory copying
  needed when loading a binobj format file.
 * Fixed a couple places where variables could be used before they were
  initialized.
 * Various property manager fixes and improvements.
 * Fixes to cloud layer management code.
 * Made the sky dome more flexible to facilitate use in other applications.
 New in 0.0.18
 * April 20, 2002
 * Created a src/libs subdirectory for several packages that need to be
  installed by the user but are used by many other packages and may already
  be installed.  So we just bundle the source separately as a convenience
  if the user needs to build and install these.
 * Upgrade to zlib-1.1.4 (security fix)
 * Upgrade to metakit-2.4.2-32.tar.gz (latest upstream release)
 * Added support for point objects in the scenery file format.
 * Additions to the binary file format to make it *much* more flexible.
  For each major primitive type: points, triangles, fans, and strips, you
  can specify an index list of vertices, normals, colors, and texture
  coordinates.  You can skip any of these you like to save on space.
 * Added support for new file features in the binary -> ascii scenery file
  decoder.
 * Various code clean ups.
 * Separate XML I/O operations into a separate header file.
 * Major property manager rewrite, then lots of followup cleaning and
  improvements.
 New in 0.0.17 (final)
 * February 16, 2002
 * Explicitely reset the glBlendFunc() after drawing the moon for the
  Voodoo2 linux driver since it seems to have a bug in glPopAttrib().
 New in 0.0.17pre2
 * February 13, 2002
 * Replaced some cout's with SG_LOG's
 New in 0.0.17pre1
 * February 12, 2002
 * Removed metakit and zlib from build process.  Tarballs are still included
  for those who's systems don't provide these packages.
 * MSVC fixes.
 * IRIX fixes.
 * Mingwin fixes.
 * Mac OS X fixes.
 * FreeBSD fixes.
 * Added support for Intel's C++ compiler under Linux.
 * Attempt to build in support for various non-compatible automake/autoconf
  versions.
 * Fix for a problem that could lead to a bogus build for people with voodoo
  cards.
 * Added Norman's jpegfactory code which can create jpeg format screen shots
  of a live running application.
 * implemented set/get_log_classes and set/get_log_priority.
 * Socket library improvements.
 * Added a C++ exception abstraction.
 * Property manager fixes and improvements including node path caching
  and debug tracing of property reads/writes.
 * Updates/fixes to xml handling.
 New in 0.0.16
 * July 12, 2001
 * Various changes to the property manager implementation to better support
  dumping out the desired portions of the property tree to file.
 * Don't compile the metakit demos by default (causes problems for Irix)'
 * Other various tweaks for Irix.
 * Added a virtual destructor to XMLVisitor to fix a warning message.
 * Check for valid hostname lookup in sg_socket.cxx
 * Add a function to return modified julian date without creating an
  entire SGTime class.  This avoids an extraneous warning about not
  being able to find a timezone.
 * Created a mailing list for cvs commit messages.
 * Fixed a potential array under/over run bug in interpolator.cxx
 * Removed all references to SGValue from the property manager.  Added
  support for an "archive" bit in the property manager to control
  which values get written out.
 * Added SGCommandState class so that commands can compile and save
  copies of their arguments for efficiency if they are called multiple
  times.
 * Added Brian Baul's "tr" tiled rendering low level support library.
  This along with some higher level code in flightgear allows us to do
  ultra-hires tiled screen dumps suitable for large format printers.
  (Norman Vine)
 New in 0.0.15
 * June 20, 2001
 * Various bug fixes, tweaks, and optimizations.
 * Added a command manager (analogous to the property manager)
 * Better Irix Mips support.
 * Various gcc-3.0 fixes.
 * Various MSVC fixes.
 * Added MSVC project files (automatically generated from the unix
  automake configuration files.)
 * Removed total size limitation on interpolation table module.
 * Various Cygwin fixes.
 * Added some convenience functions to point3d.
 * Various compiler warning fixes.
 * Added a thread wrapper class (currently only supports pthreads)
 * Added IO routines for a lowlevel, native simgear binary 3d file
  format optimized for TerraGear terrain.
 * Better endianness checking and support for the binary file
  read/write routines.
 * Added doxygen comments for all public interface code.  Documentation
  can be accessed via the SimGear web page.
 * Many FG -> SG name space changes for better consistency throughout
  this package.
 * Added property aliases, repeated name tags, and a general xml
  inclusion facilities.  Many other property manager clean ups
  following a complete rewrite.
 * Fixed some critical null pointer bugs in property manager.
 * Magnetic variation can now be fetched for any arbitrary location.
 New in 0.0.14
 * December 14, 2000
 * Added a module to manage waypoints and routes, calculate bearing and
  distance to next waypoint, lateral distance off route, etc.
 * Moved some of the basic time management code over from flightgear.
 * Bucket dimensions can be returned in meters
 * Added SOCK_STREAM (TCP) socket support to the networking code.
 * Updated random number generator interface so application can provide
  it's own seed value as well as use the default time seed.
 * Added a routine to calculate the distance between a point and a line segment.
 * Updates to the property manager and the property list loader/saver.
 * Added an explanation of the rational behind our terrain texture coordinate
  generation code.
 * Fixed sky dome so that the color at the horizon will always match
  the specified fog color.
 * Did a fair amount of fg -> sg name space updating (lots left to do.)
 * Added support for KAI C++ on linux.
 * MSVC tweaks.
 * MacOS tweaks.
 * FreeBSD tweaks.
 New in 0.0.13
 * September 14, 2000
 * Added support for reading and writing xml files (easyxml)
 * Then updates to property manager and xml code.
 * Update magnetic variation code.
 * Sky code now uses glPushAttrib and glPopAttrib so it plays better with
  other ssg based apps.
 * MacOS tweaks.
 * MSVC tweaks.
 New in 0.0.12
 * July 19, 2000
 * Converted project license from GPL to LGPL.
 * Moved low level IO (socket, file, serial) code over to SimGear.
 * Moved ephemeral code into simgear
 * Moved basic world time code into simgear
 * Added a property manager (registry)
 * Some documentation added.
 New in 0.0.11
 * July 3, 2000
 * Replaced gdbm with metakit
 * Added drop in sky (depends on plib)
 * Added spherical course and dist given two points calculations
 * MSVC5 fixes
 * Math/bucket/tiling tweaks from Norman Vine
 New in 0.0.7
 * March 29, 2000
 * Added support for RedHat package building contributed by Habibie 
@@ -10,18 +418,22 @@ New in 0.0.7
 * Optimizations and bullet proofing of magnetic variation code by Norman 
  Vine and Ed Williams
 New in 0.0.6
 * March 27, 2000
 * Added Nima World Magnetic Model 2000 contributed by Ed Williams
 * Fixes for MSVC++
 New in 0.0.5
 * March 17, 2000
 * Restructured directory layout to facilitate windows/mac IDE builds.
 New in 0.0.4
 * Removed mat3.h and friends (we now use plib's sg lib for these sorts of 
  things.)
 New in 0.0.3
-* Release that conincides with FlightGear-0.7.2
+* Release that coincides with FlightGear-0.7.2
@@ -0,0 +1 @@
 [ Nothing here at this time. ]
@@ -0,0 +1,24 @@
 This document describes how to build SimGear using the supplied workspace and
 project files.  
 Unpack the SimGear source file into your work directory.  This creates a new
 subdirectory called SimGear-X.Y.Z.  Rename this to SimGear.  Before we can
 build SimGear you must unpack and build the third party libraries metakit and
 zlib.  Sources for these are included in the SimGear/src-libs directory.
 Unpack these into the top level SimGear directory.  At this point your
 directory structure should look something like this:
 <work_dir>/
  SimGear/
    metakit-x.y.z/
    simgear/
    src-libs/
    zlib-x.y.z/
 Now open the SimGear workspace.  This workspace file contains projects for
 building metakit(mklib), SimGear and zlib.  Select each project as the active
 project and build all.  Order is unimportant since there are no dependencies
 between the projects.
 The workspace and project files are generated by a perl script with extra
 input from the am2dsp.cfg file.
@@ -0,0 +1,27 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 You *must* have OpenSceneGraph (OSG) installed to build this version of 
 FlightGear.
 Notice that FlightGear 1.9.0 requires at least version 2.7.8. Using earlier 
 versions of OSG will yield serious rendering bugs. 
 You can get the latest version of OSG from:
 http://www.openscenegraph.org/
 Build notes:
 Unzip the file OpenSceneGraph-x.x.zip and install using the following
 commands:
 unzip OpenSceneGraph-x.x
 cd OpenSceneGraph
 ccmake .
 [ While running ccmake: press 'c' to configure, press 'c' once more, and
  then press 'g' to generate and exit ]
 make 
 sudo make install
@@ -0,0 +1,29 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 You *must* have the development components of OpenAL installed on your system
 to build FlightGear!"  You can get a copy here:
      http://connect.creativelabs.com/openal/default.aspx
 Build notes:
 You can download a versioned release of the openal library from 
 http://www.openal.org/downloads.html. Download the openal source,
 release 0.0.8 (dated February 11, 2006) and run:  
 tar xjvf openal-soft-1.5.304.tar.bz2
 cd openal-soft-1.5.304/
 ccmake .
 [ While running ccmake: press 'c' to configure, press 'c' once more, and
  then press 'g' to generate and exit ]
 The alut library is also required, but comes separately in the package
 freelut-1.1.0.tar.gz. This package can be downloaded from the same page
 (http://connect.creativelabs.com/openal/default.aspx). Download and run:
 tar xzvf freelut-1.1.0.tar.gz
 cd freealut-1.1.0
 ./configure
 make
 sudo make install
@@ -0,0 +1,32 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 You *must* have plib version 1.8.5 or later installed on your system
 to build FlightGear!"  Flight Gear is no longer compatible with the
 earlier versions of the library.
 You can get the latest version of plib from:
    http://plib.sourceforge.net
 Build notes:
 You should be able to just run "./configure" to configure the package
 and use all of plib's defaults.  Then run "make" followed by "make
 install".  By default, plib installs itself into /usr so if you don't
 like this, be sure to specify an alternate prefix such as --prefix=/usr/local
 As of this writing (2007-11-18), many linux distributions are shipped with a 
 working version of plib, so chances are that this library is already 
 installed. It should be noted, that currently plib version no longer compiles
 using recent versions of gcc (confirmed on version gcc 4.1.2, as shipped with 
 SuSe 10.2). As a workaround, it is possible to either use plib SVN. Run the 
 following commands: 
 svn co https://plib.svn.sourceforge.net/svnroot/plib/trunk plib
 cd plib
 ./autogen.sh
 ./configure
 make
 make install
@@ -0,0 +1,8 @@
 zlib is prerequisite for compiling SimGear and FlightGear.  You can fetch
 the latest version of zlib from:
    http://www.zlib.net
 Most modern unix distributions (and cygwin) come with a version of zlib
 already installed or available to install as a package.
@@ -0,0 +1 @@
 03/25/2001 - Resolve location of Sky dome implimentation documentation.
@@ -0,0 +1,205 @@
 A very special thanks is due to the following people and groups.
 Note: as hard as we've tried, it is impossible to perfectly maintain
 this file.  If you are aware of someone who you think should be
 included here, PLEASE let me know.  Projects like this are made
 possible only by the help and hard work of others.  I want to properly
 credit everyone who has contributed to this project.
 Raul Alonzo <amil@las.es>
  Mr. Alonzo is the author of Ssystem and provided his kind permission 
  for using the moon texture. I also used parts of his code as a template
  when adding the texture.  Ssystem Homepage can be found at:
  http://www1.las.es/~amil/ssystem
 Paul Bleisch <pbleisch@acm.org>
  Paul redid the "debug" system so that it would be much more flexible,
  so it could be easily disabled for production system, and so that 
  messages for certain subsystems could be selectively enabled.
  Also contributed a first stab at a config file/command line parsing
  system.
 Bernie Bright <bbright@c031.aone.net.au>
  Many C++ style, usage, and implementation improvements.  
  STL portability, tons o' stuff. :-)
  Currently trying to get a BeOS port together but life keeps getting 
  in the way!
 Gene Buckle <geneb@deltasoft.com>
  Gene has done a lot of work getting FG to compile with the MSVC++
  compiler.  Also, he has pushed, proded, and bugged me endlessly to
  do my stuff right.  (I mean that in a good way, because sometimes
  when the little nudge in the right direction isn't working, I need
  a good hard shove.) :-)
 John Check <j4strngs@rockfish.net>
  Cloud textures
 Jean-Francois Doue
  Vector 2D, 3D, 4D and Matrix 3D and 4D inlined C++ classes.  (Based on
  Graphics Gems IV ed. Paul S. Heckbert)
  http://www.animats.com/simpleppp/ftp/public_html/topics/developers.html
 Melchior Franz
  METAR parser and fetcher. "material" animation (based on Jim Wilsons's
  "emission" animation). Debugging and extension of property listener
  features. Addition of removeChildren.
 Mathias Froehlich
  Reworked and cleaned up large parts of the infrastructure, of math
  files, animations and rendering in preparation of a transition to
  the OSG library. Added new handlers for shared and referenced objects.
 Bruce Finney <bfinney@gte.net>
  MSVC5 compatibility.
 Jean-loup Gailly and Mark Adler <zlib@gzip.org>
  Authors of the zlib library.  Used for on-the-fly compression and
  decompression routines.
  http://www.cdrom.com/pub/infozip/zlib/
 Thomas Gellekum <tg@ihf.rwth-aachen.de>
  Changes and updates for compiling on FreeBSD
 Habibie <habibie@MailandNews.com>
  RedHat package building changes for SimGear.
 Bruce Jackson of NASA <e.b.jackson@larc.nasa.gov> 
  Developed the LaRCsim code under funding by NASA which we use to provide
  the flight model. Bruce has patiently answered my many, many questions.
  http://dcb.larc.nasa.gov/www/DCBStaff/ebj/ebj.html
 Maik Justus
  Fixed an old bug in the SGPropertyNode class.
 Richard Kaszeta <bofh@me.umn.edu>
  Contributed screen buffer to ppm screen shot routine.
  Rich has also helped in the early development of the Flight Gear "altitude 
  hold autopilot module" by teaching Curt Olson the basics of Control Theory 
  and helping him code and debug early versions. Curt's "Boss" Bob Hain
  also contributed <bob@me.umn.edu>.  Further details available at:
  http://www.menet.umn.edu/~curt/fgfs/Docs/Autopilot/AltitudeHold/AltitudeHold.html
  Rich's Homepage: http://www.menet.umn.edu/~kaszeta
 Tom Knienieder <tom@knienieder.com>
  Ported Steve's Audio library first to OpenBSD and IRIX and
  after that also to Win32
 David Megginson <david@megginson.com>
  SimGear property manager/registry
 Tim Moore
  Ported the (chrome) "shader" animation to OSG, and helped with porting
  the "material" animation.
 Curt Olson http://www.flightgear.org/~curt/
  Curt is responsible for overall project and source code management.
  He has his hands in many of the areas.
 Petter Reinholdtsen <pere@games.no>
  Incorporated the Gnu automake/autoconf system (with libtool).
  This should streamline and standardize the build process for all
  Unix-like platforms.  It should have little effect on IDE type 
  environments since these don't use the Unix make system.
 Paul Schlyter <pausch@saaf.se>  
  Mr. Schlyter provided Durk Talsma with all the information 
  he needed to write the astro code. Mr. S. is also willing 
  to answer astro-related questions whenever one needs to.
  http://welcome.to/pausch
 Durk Talsma <d.talsma@chello.nl>
  Accurate Sun, Moon, and Planets. 
  Sun changes color based on position in sky.
  Moon has correct phase and blends well into the sky.
  Planets are correctly positioned and have proper magnitude.
  Added time zone support in the SGTime class.
  Help with time functions, gui, and other misc stuff.
  http://people.a2000.nl/dtals
 Mark Vallevand <Mark.Vallevand@UNISYS.com>
  Contributed some METAR parsing code.
  Contributed some win32 screen printing routines.
 Gary R. Van Sickle <tiberius@braemarinc.com>
  Contributed some initial GameGLUT support and other fixes.
  Has done some interesting preliminary work on a binary file format
  http://www.woodsoup.org/projs/ORKiD/fgfs.htm
  Has set up a 'Cygwin Tips' site that has been very helpful to many 
  people in getting a Cygwin Unix-on-Windows build environment set up
  so they can build FG effectively. 
  http://www.woodsoup.org/projs/ORKiD/cygwin.htm
 Norman Vine <nhv@yahoo.com>
  Provided more than uncountable URL's to the "FlightGear Community".
  Many performance optimizations throughout the code.  
  Lots of windoze related contributions.
  Contributed wgs84 distance and course routines.
  Contributed a great circle route autopilot mode based on wgs84 routines.
 Ed Williams <Ed_Williams@compuserve.com>
  Contributed magnetic variation code (impliments Nima WMM 2000)
  We've also borrowed from Ed's wonderful aviation formulary at various
  times as well.
  http://www.best.com/~williams/index.html
 Jean-Claude Wippler <jcw@equi4.com>
  Author of MetaKit - a portable, embeddible database with a portable
  data file format.  This software is not GPL'd but the author is kindly
  allowing us to bundle MetaKit with our code.  MetaKit has a liberal
  X/MIT-style license.  Please see the following URL for more info:
  http://www.equi4.com/metakit
 WoodSoup Project  http://www.woodsoup.org
  Provided computing resources and services so that the Flight Gear 
  project could have real home.  This includes, web services, 
  ftp services, shell accounts, email lists, dns services, etc.
 Robert Allan Zeh <raz@cmg.FCNBD.COM>
  Helped me tremendously in figuring out the Cygnus win32 compiler and
  how to link with .dll's.  With out him the first runable win32
  version of FG would have been impossible.
 NOTE:
 ----
 THIS DOCUMENT WAS INITIALLY WRITTEN BY 
 Curt L. Olson  <http://www.flightgear.org/~curt>
 05 Jul 2000 Removed non-SimGear entries (CLO)
 08 Mar 2000 CONTENTS RESEARCHED AND UPDATED by 
            Oliver Delise  <delise@mail.isis.de>
@@ -1,330 +0,0 @@
 /* acconfig.h
   This file is in the public domain.
   Descriptive text for the C preprocessor macros that
   the distributed Autoconf macros can define.
   No software package will use all of them; autoheader copies the ones
   your configure.in uses into your configuration header file templates.
   The entries are in sort -df order: alphabetical, case insensitive,
   ignoring punctuation (such as underscores).  Although this order
   can split up related entries, it makes it easier to check whether
   a given entry is in the file.
   Leave the following blank line there!!  Autoheader needs it.  */
 /* Define if on AIX 3.
   System headers sometimes define this.
   We just want to avoid a redefinition error message.  */
 #ifndef _ALL_SOURCE
 #undef _ALL_SOURCE
 #endif
 /* Define if using alloca.c.  */
 #undef C_ALLOCA
 /* Define if type char is unsigned and you are not using gcc.  */
 #ifndef __CHAR_UNSIGNED__
 #undef __CHAR_UNSIGNED__
 #endif
 /* Define if the closedir function returns void instead of int.  */
 #undef CLOSEDIR_VOID
 /* Define to empty if the keyword does not work.  */
 #undef const
 /* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
   This function is required for alloca.c support on those systems.  */
 #undef CRAY_STACKSEG_END
 /* Define for DGUX with <sys/dg_sys_info.h>.  */
 #undef DGUX
 /* Define if you have <dirent.h>.  */
 #undef DIRENT
 /* Define to enable audio support */
 #undef ENABLE_AUDIO_SUPPORT
 /* Define to enable GLUT joystick support (limited to 3 axes) */
 #undef ENABLE_GLUT_JOYSTICK
 /* Define to enable plib joystick support (recommended) */
 #undef ENABLE_PLIB_JOYSTICK
 /* Define to eliminate all trace of debugging messages such as for a 
   release build */
 #undef FG_NDEBUG
 /* Define to include Oliver's networking support */
 #undef FG_NETWORK_OLK
 /* Define to avoid Christian's new weather code */
 #undef FG_OLD_WEATHER
 /* Define if we are building FGFS (should always be defined) */
 #undef FGFS
 /* Define to enable 3dfx/glide render in a window hack under unix.
   This probably won't work under windows. */
 #undef XMESA
 #undef FX
 /* Define to the type of elements in the array set by `getgroups'.
   Usually this is either `int' or `gid_t'.  */
 #undef GETGROUPS_T
 /* Define if the `getloadavg' function needs to be run setuid or setgid.  */
 #undef GETLOADAVG_PRIVILEGED
 /* Define if the `getpgrp' function takes no argument.  */
 #undef GETPGRP_VOID
 /* Define to `int' if <sys/types.h> doesn't define.  */
 #undef gid_t
 /* Define if you have alloca, as a function or macro.  */
 #undef HAVE_ALLOCA
 /* Define if you have <alloca.h> and it should be used (not on Ultrix).  */
 #undef HAVE_ALLOCA_H
 /* Define if you external variables daylight.  */
 #undef HAVE_DAYLIGHT
 /* Define if you don't have vprintf but do have _doprnt.  */
 #undef HAVE_DOPRNT
 /* Define if your system has a working fnmatch function.  */
 #undef HAVE_FNMATCH
 /* Define if your system has its own `getloadavg' function.  */
 #undef HAVE_GETLOADAVG
 /* Define if you have getrusage() */
 #undef HAVE_GETRUSAGE
 /* Define if you have the getmntent function.  */
 #undef HAVE_GETMNTENT
 /* Define if you have the gpc library and headers installed.  */
 #undef HAVE_GPC_H
 /* Define if the `long double' type works.  */
 #undef HAVE_LONG_DOUBLE
 /* Define if you support file names longer than 14 characters.  */
 #undef HAVE_LONG_FILE_NAMES
 /* Define if you have a working `mmap' system call.  */
 #undef HAVE_MMAP
 /* Define if system calls automatically restart after interruption
   by a signal.  */
 #undef HAVE_RESTARTABLE_SYSCALLS
 /* Define if you have rint() which rounds to closest int but returns
   result as a double data type.  */
 #undef HAVE_RINT
 /* Define if your struct stat has st_blksize.  */
 #undef HAVE_ST_BLKSIZE
 /* Define if your struct stat has st_blocks.  */
 #undef HAVE_ST_BLOCKS
 /* Define if you have the strcoll function and it is properly defined.  */
 #undef HAVE_STRCOLL
 /* Define if your struct stat has st_rdev.  */
 #undef HAVE_ST_RDEV
 /* Define if you have the strftime function.  */
 #undef HAVE_STRFTIME
 /* Define if you have <sys/param.h>  */
 #undef HAVE_SYS_PARAM_H
 /* Define if you have <sys/stat.h> that is POSIX.1 compatible.  */
 #undef HAVE_SYS_STAT_H
 /* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
 #undef HAVE_SYS_WAIT_H
 /* Define if you have timegm() */
 #undef HAVE_TIMEGM
 /* Define if you external variables timezone.  */
 #undef HAVE_TIMEZONE
 /* Define if your struct tm has tm_zone.  */
 #undef HAVE_TM_ZONE
 /* Define if you don't have tm_zone but do have the external array
   tzname.  */
 #undef HAVE_TZNAME
 /* Define if you have <unistd.h>.  */
 #undef HAVE_UNISTD_H
 /* Define if utime(file, NULL) sets file's timestamp to the present.  */
 #undef HAVE_UTIME_NULL
 /* Define if you have <vfork.h>.  */
 #undef HAVE_VFORK_H
 /* Define if you have the vprintf function.  */
 #undef HAVE_VPRINTF
 /* Define if you have the wait3 system call.  */
 #undef HAVE_WAIT3
 /* Define if you have gdbm installed system wide.  */
 #undef HAVE_GDBM
 /* Define if you have zlib installed system wide.  */
 #undef HAVE_ZLIB
 /* Define as __inline if that's what the C compiler calls it.  */
 #undef inline
 /* Define if int is 16 bits instead of 32.  */
 #undef INT_16_BITS
 /* Define if long int is 64 bits.  */
 #undef LONG_64_BITS
 /* Define if major, minor, and makedev are declared in <mkdev.h>.  */
 #undef MAJOR_IN_MKDEV
 /* Define if major, minor, and makedev are declared in <sysmacros.h>.  */
 #undef MAJOR_IN_SYSMACROS
 /* Define if on MINIX.  */
 #undef _MINIX
 /* Define to `int' if <sys/types.h> doesn't define.  */
 #undef mode_t
 /* Define if you don't have <dirent.h>, but have <ndir.h>.  */
 #undef NDIR
 /* Define if you have <memory.h>, and <string.h> doesn't declare the
   mem* functions.  */
 #undef NEED_MEMORY_H
 /* Define if your struct nlist has an n_un member.  */
 #undef NLIST_NAME_UNION
 /* Define if you have <nlist.h>.  */
 #undef NLIST_STRUCT
 /* Define if your C compiler doesn't accept -c and -o together.  */
 #undef NO_MINUS_C_MINUS_O
 /* Define to `long' if <sys/types.h> doesn't define.  */
 #undef off_t
 /* Define to package name */
 #undef PACKAGE
 /* Define to `int' if <sys/types.h> doesn't define.  */
 #undef pid_t
 /* Define if the system does not provide POSIX.1 features except
   with this defined.  */
 #undef _POSIX_1_SOURCE
 /* Define if you need to in order for stat and other things to work.  */
 #undef _POSIX_SOURCE
 /* Define as the return type of signal handlers (int or void).  */
 #undef RETSIGTYPE
 /* Define if the `setpgrp' function takes no argument.  */
 #undef SETPGRP_VOID
 /* Define if the setvbuf function takes the buffering type as its second
   argument and the buffer pointer as the third, as on System V
   before release 3.  */
 #undef SETVBUF_REVERSED
 /* Define to `unsigned' if <sys/types.h> doesn't define.  */
 #undef size_t
 /* If using the C implementation of alloca, define if you know the
   direction of stack growth for your system; otherwise it will be
   automatically deduced at run-time.
 	STACK_DIRECTION > 0 => grows toward higher addresses
 	STACK_DIRECTION < 0 => grows toward lower addresses
 	STACK_DIRECTION = 0 => direction of growth unknown
 */
 #undef STACK_DIRECTION
 /* Define if the `S_IS*' macros in <sys/stat.h> do not work properly.  */
 #undef STAT_MACROS_BROKEN
 /* Define if you have the ANSI C header files.  */
 #undef STDC_HEADERS
 /* Define on System V Release 4.  */
 #undef SVR4
 /* Define if you don't have <dirent.h>, but have <sys/dir.h>.  */
 #undef SYSDIR
 /* Define if you don't have <dirent.h>, but have <sys/ndir.h>.  */
 #undef SYSNDIR
 /* Define if `sys_siglist' is declared by <signal.h>.  */
 #undef SYS_SIGLIST_DECLARED
 /* Define if you can safely include both <sys/time.h> and <time.h>.  */
 #undef TIME_WITH_SYS_TIME
 /* Define if your <sys/time.h> declares struct tm.  */
 #undef TM_IN_SYS_TIME
 /* Define to `int' if <sys/types.h> doesn't define.  */
 #undef uid_t
 /* Define for Encore UMAX.  */
 #undef UMAX
 /* Define for Encore UMAX 4.3 that has <inq_status/cpustats.h>
   instead of <sys/cpustats.h>.  */
 #undef UMAX4_3
 /* Define if you do not have <strings.h>, index, bzero, etc..  */
 #undef USG
 /* Define to version number */
 #undef VERSION
 /* Define vfork as fork if vfork does not work.  */
 #undef vfork
 /* Define if the closedir function returns void instead of int.  */
 #undef VOID_CLOSEDIR
 /* Define if compiling on a Winbloze (95, NT, etc.) platform */
 #undef WIN32
 /* Define if your processor stores words with the most significant
   byte first (like Motorola and SPARC, unlike Intel and VAX).  */
 #undef WORDS_BIGENDIAN
 /* Define if the X Window System is missing or not being used.  */
 #undef X_DISPLAY_MISSING
 /* Define if lex declares yytext as a char * by default, not a char[].  */
 #undef YYTEXT_POINTER
 /* Leave that blank line there!!  Autoheader needs it.
   If you're adding to this file, keep in mind:
   The entries are in sort -df order: alphabetical, case insensitive,
   ignoring punctuation (such as underscores).  */
@@ -0,0 +1,686 @@
 dnl
 dnl originally from ncftp 2.3.0
 dnl added wi_EXTRA_PDIR and wi_ANSI_C
 dnl $Id$
 dnl
 AC_DEFUN([wi_EXTRA_IDIR], [
 incdir="$1"
 if test -r $incdir ; then
 	case "$CPPFLAGS" in
 		*-I${incdir}*)
 			# echo "   + already had $incdir" 1>&6
 			;;
 		*)
 			if test "$CPPFLAGS" = "" ; then
 				CPPFLAGS="-I$incdir"
 			else
 				CPPFLAGS="$CPPFLAGS -I$incdir"
 			fi
 			echo "   + found $incdir" 1>&6
 			;;
 	esac
 fi
 ])
 dnl
 dnl
 dnl
 dnl
 AC_DEFUN([wi_EXTRA_LDIR], [
 mylibdir="$1"
 if test -r $mylibdir ; then
 	case "$LDFLAGS" in
 		*-L${mylibdir}*)
 			# echo "   + already had $mylibdir" 1>&6
 			;;
 		*)
 			if test "$LDFLAGS" = "" ; then
 				LDFLAGS="-L$mylibdir"
 			else
 				LDFLAGS="$LDFLAGS -L$mylibdir"
 			fi
 			echo "   + found $mylibdir" 1>&6
 			;;
 	esac
 fi
 ])
 dnl
 dnl __FP__
 dnl
 dnl
 AC_DEFUN([wi_EXTRA_PDIR], [
 progdir="$1"
 if test -r $progdir ; then
 	case "$PATH" in
 		*:${progdir}*)
 			# echo "   + already had $progdir" 1>&6
 			;;
 		*${progdir}:*)
 			# echo "   + already had $progdir" 1>&6
 			;;
 		*)
 			if test "$PATH" = "" ; then
 				PATH="$progdir"
 			else
 				PATH="$PATH:$progdir"
 			fi
 			echo "   + found $progdir" 1>&6
 			;;
 	esac
 fi
 ])
 dnl
 dnl
 dnl If you want to also look for include and lib subdirectories in the
 dnl $HOME tree, you supply "yes" as the first argument to this macro.
 dnl
 dnl If you want to look for subdirectories in include/lib directories,
 dnl you pass the names in argument 3, otherwise pass a dash.
 dnl
 AC_DEFUN([wi_EXTRA_DIRS], [echo "checking for extra include and lib directories..." 1>&6
 ifelse([$1], yes, [dnl
 b1=`cd .. ; pwd`
 b2=`cd ../.. ; pwd`
 exdirs="$HOME $j $b1 $b2 $prefix $2"
 ],[dnl
 exdirs="$prefix $2"
 ])
 subexdirs="$3"
 if test "$subexdirs" = "" ; then
 	subexdirs="-"
 fi
 for subexdir in $subexdirs ; do
 if test "$subexdir" = "-" ; then
 	subexdir=""
 else
 	subexdir="/$subexdir"
 fi
 for exdir in $exdirs ; do
 	if test "$exdir" != "/usr" || test "$subexdir" != ""; then
 		incdir="${exdir}/include${subexdir}"
 		wi_EXTRA_IDIR($incdir)
 		mylibdir="${exdir}/lib${subexdir}"
 		wi_EXTRA_LDIR($mylibdir)
 		progdir="${exdir}/bin${subexdir}"
 		wi_EXTRA_PDIR($progdir)
 	fi
 done
 done
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_HPUX_CFLAGS],
 [AC_MSG_CHECKING(if HP-UX ansi C compiler flags are needed)
 AC_REQUIRE([AC_PROG_CC])
 os=`uname -s | tr '[A-Z]' '[a-z]'`
 ac_cv_hpux_flags=no
 if test "$os" = hp-ux ; then
 	if test "$ac_cv_prog_gcc" = yes ; then
 		if test "$CFLAGS" != "" ; then
 			# Shouldn't be in there.
 			CFLAGS=`echo "$CFLAGS" | sed 's/-Aa//g'`
 		fi
 	else
 		# If you're not using gcc, then you better have a cc/c89
 		# that is usable.  If you have the barebones compiler, it
 		# won't work.  The good compiler uses -Aa for the ANSI
 		# compatible stuff.
 		x=`echo $CFLAGS | grep 'Aa' 2>/dev/null`
 		if test "$x" = "" ; then
 			CFLAGS="$CFLAGS -Aa"
 		fi
 		ac_cv_hpux_flags=yes
 	fi
 	# Also add _HPUX_SOURCE to get the extended namespace.
 	x=`echo $CFLAGS | grep '_HPUX_SOURCE' 2>/dev/null`
 	if test "$x" = "" ; then
 		CFLAGS="$CFLAGS -D_HPUX_SOURCE"
 	fi
 fi
 AC_MSG_RESULT($ac_cv_hpux_flags)
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_CFLAGS], [AC_REQUIRE([AC_PROG_CC])
 wi_HPUX_CFLAGS
 	if test "$CFLAGS" = "" ; then
 		CFLAGS="-O"
 	elif test "$ac_cv_prog_gcc" = "yes" ; then
 		case "$CFLAGS" in
 			*"-g -O"*)
 				#echo "using -g as default gcc CFLAGS" 1>&6
 				CFLAGS=`echo $CFLAGS | sed 's/-g\ -O/-O/'`
 				;;
 			*"-O -g"*)
 				# Leave the -g, but remove all -O options.
 				#echo "using -g as default gcc CFLAGS" 1>&6
 				CFLAGS=`echo $CFLAGS | sed 's/-O\ -g/-O/'`
 				;;
 		esac
 	fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_PROTOTYPES], [
 AC_MSG_CHECKING(if the compiler supports function prototypes)
 AC_TRY_COMPILE(,[extern void exit(int status);],[wi_cv_prototypes=yes
 AC_DEFINE(PROTOTYPES)],wi_cv_prototypes=no)
 AC_MSG_RESULT($wi_cv_prototypes)
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_ANSI_C], [
 AC_MSG_CHECKING(ANSI-style function definitions)
 AC_TRY_COMPILE(,[int blubb(int x) { return 0; }],[wi_cv_ansi_funcs=yes
 AC_DEFINE(ANSI_FUNCS)],wi_cv_ansi_funcs=no)
 AC_MSG_RESULT($wi_cv_ansi_funcs)
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_HEADER_SYS_SELECT_H], [
 # See if <sys/select.h> is includable after <sys/time.h>
 if test "$ac_cv_header_sys_time_h" = no ; then
 AC_CHECK_HEADERS(sys/time.h sys/select.h)
 else
 AC_CHECK_HEADERS(sys/select.h)
 fi
 if test "$ac_cv_header_sys_select_h" = yes ; then
 	AC_MSG_CHECKING([if <sys/select.h> is compatible with <sys/time.h>])
 	selecth=yes
 	if test "$ac_cv_header_sys_time_h" = yes ; then
 		AC_TRY_COMPILE([#include <sys/time.h>
 		#include <sys/select.h>],[
 		fd_set a;
 		struct timeval tmval;
 		tmval.tv_sec = 0;],selecth=yes,selecth=no)
 		if test "$selecth" = yes ; then
 			AC_DEFINE(CAN_USE_SYS_SELECT_H)
 		fi
 	fi
 	AC_MSG_RESULT($selecth)
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_LIB_RESOLV], [
 # See if we could access two well-known sites without help of any special
 # libraries, like resolv.
 AC_TRY_RUN([
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 main()
 {
 	struct hostent *hp1, *hp2;
 	int result;
 	hp1 = gethostbyname("gatekeeper.dec.com");
 	hp2 = gethostbyname("ftp.ncsa.uiuc.edu");
 	result = ((hp1 != (struct hostent *) 0) && (hp2 != (struct hostent *) 0));
 	exit(! result);
 }],look_for_resolv=no,look_for_resolv=yes,look_for_resolv=yes)
 AC_MSG_CHECKING([if we need to look for -lresolv])
 AC_MSG_RESULT($look_for_resolv)
 if test "$look_for_resolv" = yes ; then
 AC_CHECK_LIB(resolv,main)
 else
 	ac_cv_lib_resolv=no
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_LIB_NSL], [
 AC_MSG_CHECKING(if we can use -lnsl)
 ac_save_LIBS="$LIBS";
 LIBS="$LIBS -lnsl";
 AC_CACHE_VAL(r_cv_use_libnsl, [
 AC_TRY_RUN(
 main() { if (getpwuid(getuid())) exit(0); exit(-1); },
 nc_cv_use_libnsl=yes, nc_cv_use_libnsl=no, nc_cv_use_libnsl=no)
 ])
 if test "$nc_cv_use_libnsl" = "no"; then LIBS="$ac_save_LIBS"; fi
 AC_MSG_RESULT($nc_cv_use_libnsl)
 ])dnl
 dnl
 dnl
 dnl
 AC_DEFUN([nc_PATH_PROG_ZCAT], [
 AC_PATH_PROG(GZCAT,gzcat)
 AC_PATH_PROG(ZCAT,zcat)
 if test "x$GZCAT" = x ; then
 	if test "x$ZCAT" != x ; then
 		# See if zcat is really gzcat.  gzcat has a --version option, regular
 		# zcat does not.
 		AC_MSG_CHECKING(if zcat is really gzcat in disguise)
 		if $ZCAT --version 2> /dev/null ; then
 			AC_DEFINE_UNQUOTED(GZCAT, "$ZCAT")
 			AC_MSG_RESULT(yes)
 		else
 			AC_MSG_RESULT(no)
 		fi
 	fi
 else
 	AC_DEFINE_UNQUOTED(GZCAT, "$GZCAT")
 fi
 if test "x$ZCAT" != x ; then
 	AC_DEFINE_UNQUOTED(ZCAT, "$ZCAT")
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_SYSV_EXTRA_DIRS], [
 # Use System V because their curses extensions are required.  This must
 # be done early so we use the -I and -L in the library checks also.
 # This is mostly a Solaris/SunOS hack.  Note that doing this will also
 # use all of the other System V libraries and headers.
 AC_MSG_CHECKING(for alternative System V libraries)
 if test -f /usr/5include/curses.h ; then
 	CPPFLAGS="$CPPFLAGS -I/usr/5include"
 	LDFLAGS="$LDFLAGS -L/usr/5lib"
 	AC_MSG_RESULT(yes)
 else
 	AC_MSG_RESULT(no)
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_DEFINE_UNAME], [
 # Get first 127 chars of all uname information.  Some folks have
 # way too much stuff there, so grab only the first 127.
 unam=`uname -a 2>/dev/null | cut -c1-127`
 if test "$unam" != "" ; then
 	AC_DEFINE_UNQUOTED(UNAME, "$unam")
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN([wi_READLINE_WITH_NCURSES], [
 # Readline and Ncurses could both define "backspace".
 # Warn about this if we have both things in our definitions list.
 if test "$ac_cv_lib_readline" = yes && test "$ac_cv_lib_ncurses" = yes ; then
 AC_MSG_CHECKING(if readline and ncurses will link together)
 j="$LIBS"
 LIBS="-lreadline -lncurses"
 AC_TRY_LINK(,[
 readline("prompt");
 endwin();
 ],k=yes,k=no)
 if test "$k" = no ; then
 	AC_MSG_RESULT(no)
 	# Remove '-lreadline' from LIBS.
 	LIBS=`echo $j | sed s/-lreadline//g`
 	ac_cv_lib_readline=no
 	AC_WARN([The versions of GNU readline and ncurses you have installed on this system
 can't be used together, because they use the same symbol, backspace. If
 possible, recompile one of the libraries with -Dbackspace=back_space, then
 re-run configure.])
 else
 	AC_MSG_RESULT(yes)
 	LIBS="$j"
 fi
 fi
 ])
 dnl
 dnl
 dnl
 dnl AC_EXT_DAYLIGHT
 dnl Check for an external variable daylight. Stolen from w3c-libwww.
 AC_DEFUN([AC_EXT_DAYLIGHT],
 [ AC_MSG_CHECKING(int daylight variable)
 AC_TRY_COMPILE([#include <time.h>], [return daylight;],
  have_daylight=yes,
  have_daylight=no)
 AC_MSG_RESULT($have_daylight)
 ])dnl
 dnl AC_EXT_TIMEZONE
 dnl Check for an external variable timezone. Stolen from tcl-8.0.
 AC_DEFUN([AC_EXT_TIMEZONE],
 [
 #
 # Its important to include time.h in this check, as some systems (like convex)
 # have timezone functions, etc.
 #
 have_timezone=no
 AC_MSG_CHECKING([long timezone variable])
 AC_TRY_COMPILE([#include <time.h>],
        [extern long timezone;
         timezone += 1;
         exit (0);],
        [have_timezone=yes
         AC_MSG_RESULT(yes)],
         AC_MSG_RESULT(no))
 #
 # On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
 #
 if test "$have_timezone" = no; then
   AC_MSG_CHECKING([time_t timezone variable])
   AC_TRY_COMPILE([#include <time.h>],
        [extern time_t timezone;
         timezone += 1;
         exit (0);],
        [have_timezone=yes
         AC_MSG_RESULT(yes)],
         AC_MSG_RESULT(no))
 fi
 ])dnl
 ## AC_BZ_SET_COMPILER: Addition by Theodore Papadopoulo
 ## Patch by Jim McKelvey: change sed -e 's/ /@/g' to sed -e 's/ /@/'
 AC_DEFUN([AC_SG_SET_COMPILER],
  [cxxwith=`echo $1 | sed -e 's/ /@/'`
   case "$cxxwith" in
     *:*@*)                 # Full initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
     ;;
     *:*)                   # Simple initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
       CXXFLAGS=$3
     ;;
     *)                     # Default values
       CXX=$2
       CXXFLAGS=$3
       CC="$2 --c"
 ##       CFLAGS=
     ;;
   esac])
 pushdef([AC_PROG_INSTALL],
 [
  dnl our own version, testing for a -p flag
  popdef([AC_PROG_INSTALL])
  dnl as AC_PROG_INSTALL works as it works we first have
  dnl to save if the user didn't specify INSTALL, as the
  dnl autoconf one overwrites INSTALL and we have no chance to find
  dnl out afterwards
  AC_PROG_INSTALL
    # OK, user hasn't given any INSTALL, autoconf found one for us
    # now we test, if it supports the -p flag
    AC_MSG_CHECKING(for -p flag to install)
    rm -f confinst.$$.* > /dev/null 2>&1
    echo "Testtest" > confinst.$$.orig
    ac_res=no
    if ${INSTALL} -p confinst.$$.orig confinst.$$.new > /dev/null 2>&1 ; then
      if test -f confinst.$$.new ; then
        # OK, -p seems to do no harm to install
        INSTALL="${INSTALL} -p"
        ac_res=yes
      fi
    fi
    rm -f confinst.$$.*
    AC_MSG_RESULT($ac_res)
  dnl the following tries to resolve some signs and wonders coming up
  dnl with different autoconf/automake versions
  dnl e.g.:
  dnl  *automake 1.4 install-strip sets A_M_INSTALL_PROGRAM_FLAGS to -s
  dnl   and has INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(A_M_INSTALL_PROGRAM_FLAGS)
  dnl   it header-vars.am, so there the actual INSTALL_PROGRAM gets the -s
  dnl  *automake 1.4a (and above) use INSTALL_STRIP_FLAG and only has
  dnl   INSTALL_PROGRAM = @INSTALL_PROGRAM@ there, but changes the
  dnl   install-@DIR@PROGRAMS targets to explicitly use that flag
  dnl  *autoconf 2.13 is dumb, and thinks it can use INSTALL_PROGRAM as
  dnl   INSTALL_SCRIPT, which breaks with automake <= 1.4
  dnl  *autoconf >2.13 (since 10.Apr 1999) has not that failure
  dnl to clean up that mess we:
  dnl  +set INSTALL_PROGRAM to use INSTALL_STRIP_FLAG
  dnl   which cleans KDE's program with automake > 1.4;
  dnl  +set INSTALL_SCRIPT to only use INSTALL, to clean up autoconf's problems
  dnl   with automake<=1.4
  dnl  note that dues to this sometimes two '-s' flags are used
    INSTALL_PROGRAM='${INSTALL} $(INSTALL_STRIP_FLAG)'
    INSTALL_SCRIPT='${INSTALL}'
 ])dnl
 # ===========================================================================
 #             http://autoconf-archive.cryp.to/ax_boost_base.html
 # ===========================================================================
 #
 # SYNOPSIS
 #
 #   AX_BOOST_BASE([MINIMUM-VERSION])
 #
 # DESCRIPTION
 #
 #   Test for the Boost C++ libraries of a particular version (or newer)
 #
 #   If no path to the installed boost library is given the macro searchs
 #   under /usr, /usr/local, /opt and /opt/local and evaluates the
 #   $BOOST_ROOT environment variable. Further documentation is available at
 #   <http://randspringer.de/boost/index.html>.
 #
 #   This macro calls:
 #
 #     AC_SUBST(BOOST_CPPFLAGS) / AC_SUBST(BOOST_LDFLAGS)
 #
 #   And sets:
 #
 #     HAVE_BOOST
 #
 # LAST MODIFICATION
 #
 #   2008-04-12
 #
 # COPYLEFT
 #
 #   Copyright (c) 2008 Thomas Porschberg <thomas@randspringer.de>
 #
 #   Copying and distribution of this file, with or without modification, are
 #   permitted in any medium without royalty provided the copyright notice
 #   and this notice are preserved.
 AC_DEFUN([AX_BOOST_BASE],
 [
 AC_ARG_WITH([boost],
 	AS_HELP_STRING([--with-boost@<:@=DIR@:>@], [use boost (default is yes) - it is possible to specify the root directory for boost (optional)]),
 	[
    if test "$withval" = "no"; then
 		want_boost="no"
    elif test "$withval" = "yes"; then
        want_boost="yes"
        ac_boost_path=""
    else
 	    want_boost="yes"
        ac_boost_path="$withval"
 	fi
    ],
    [want_boost="yes"])
 AC_ARG_WITH([boost-libdir],
        AS_HELP_STRING([--with-boost-libdir=LIB_DIR],
        [Force given directory for boost libraries. Note that this will overwrite library path detection, so use this parameter only if default library detection fails and you know exactly where your boost libraries are located.]),
        [
        if test -d $withval
        then
                ac_boost_lib_path="$withval"
        else
                AC_MSG_ERROR(--with-boost-libdir expected directory name)
        fi
        ],
        [ac_boost_lib_path=""]
 )
 if test "x$want_boost" = "xyes"; then
 	boost_lib_version_req=ifelse([$1], ,1.20.0,$1)
 	boost_lib_version_req_shorten=`expr $boost_lib_version_req : '\([[0-9]]*\.[[0-9]]*\)'`
 	boost_lib_version_req_major=`expr $boost_lib_version_req : '\([[0-9]]*\)'`
 	boost_lib_version_req_minor=`expr $boost_lib_version_req : '[[0-9]]*\.\([[0-9]]*\)'`
 	boost_lib_version_req_sub_minor=`expr $boost_lib_version_req : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
 	if test "x$boost_lib_version_req_sub_minor" = "x" ; then
 		boost_lib_version_req_sub_minor="0"
    	fi
 	WANT_BOOST_VERSION=`expr $boost_lib_version_req_major \* 100000 \+  $boost_lib_version_req_minor \* 100 \+ $boost_lib_version_req_sub_minor`
 	AC_MSG_CHECKING(for boostlib >= $boost_lib_version_req)
 	succeeded=no
 	dnl first we check the system location for boost libraries
 	dnl this location ist chosen if boost libraries are installed with the --layout=system option
 	dnl or if you install boost with RPM
 	if test "$ac_boost_path" != ""; then
 		BOOST_LDFLAGS="-L$ac_boost_path/lib"
 		BOOST_CPPFLAGS="-I$ac_boost_path/include"
 	else
 		for ac_boost_path_tmp in /usr /usr/local /opt /opt/local ; do
 			if test -d "$ac_boost_path_tmp/include/boost" && test -r "$ac_boost_path_tmp/include/boost"; then
 				BOOST_LDFLAGS="-L$ac_boost_path_tmp/lib"
 				BOOST_CPPFLAGS="-I$ac_boost_path_tmp/include"
 				break;
 			fi
 		done
 	fi
    dnl overwrite ld flags if we have required special directory with
    dnl --with-boost-libdir parameter
    if test "$ac_boost_lib_path" != ""; then
       BOOST_LDFLAGS="-L$ac_boost_lib_path"
    fi
 	CPPFLAGS_SAVED="$CPPFLAGS"
 	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
 	export CPPFLAGS
 	LDFLAGS_SAVED="$LDFLAGS"
 	LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
 	export LDFLAGS
 	AC_LANG_PUSH(C++)
     	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 	@%:@include <boost/version.hpp>
 	]], [[
 	#if BOOST_VERSION >= $WANT_BOOST_VERSION
 	// Everything is okay
 	#else
 	#  error Boost version is too old
 	#endif
 	]])],[
        AC_MSG_RESULT(yes)
 	succeeded=yes
 	found_system=yes
       	],[
       	])
 	AC_LANG_POP([C++])
 	dnl if we found no boost with system layout we search for boost libraries
 	dnl built and installed without the --layout=system option or for a staged(not installed) version
 	if test "x$succeeded" != "xyes"; then
 		_version=0
 		if test "$ac_boost_path" != ""; then
 			if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
 				for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
 					_version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
 					V_CHECK=`expr $_version_tmp \> $_version`
 					if test "$V_CHECK" = "1" ; then
 						_version=$_version_tmp
 					fi
 					VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
 					BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
 				done
 			fi
 		else
 			for ac_boost_path in /usr /usr/local /opt /opt/local ; do
 				if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
 					for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
 						_version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
 						V_CHECK=`expr $_version_tmp \> $_version`
 						if test "$V_CHECK" = "1" ; then
 							_version=$_version_tmp
 	               					best_path=$ac_boost_path
 						fi
 					done
 				fi
 			done
 			VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
 			BOOST_CPPFLAGS="-I$best_path/include/boost-$VERSION_UNDERSCORE"
            if test "$ac_boost_lib_path" = ""
            then
               BOOST_LDFLAGS="-L$best_path/lib"
            fi
 	    		if test "x$BOOST_ROOT" != "x"; then
 				if test -d "$BOOST_ROOT" && test -r "$BOOST_ROOT" && test -d "$BOOST_ROOT/stage/lib" && test -r "$BOOST_ROOT/stage/lib"; then
 					version_dir=`expr //$BOOST_ROOT : '.*/\(.*\)'`
 					stage_version=`echo $version_dir | sed 's/boost_//' | sed 's/_/./g'`
 			        	stage_version_shorten=`expr $stage_version : '\([[0-9]]*\.[[0-9]]*\)'`
 					V_CHECK=`expr $stage_version_shorten \>\= $_version`
                    if test "$V_CHECK" = "1" -a "$ac_boost_lib_path" = "" ; then
 						AC_MSG_NOTICE(We will use a staged boost library from $BOOST_ROOT)
 						BOOST_CPPFLAGS="-I$BOOST_ROOT"
 						BOOST_LDFLAGS="-L$BOOST_ROOT/stage/lib"
 					fi
 				fi
 	    		fi
 		fi
 		CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
 		export CPPFLAGS
 		LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
 		export LDFLAGS
 		AC_LANG_PUSH(C++)
 	     	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 		@%:@include <boost/version.hpp>
 		]], [[
 		#if BOOST_VERSION >= $WANT_BOOST_VERSION
 		// Everything is okay
 		#else
 		#  error Boost version is too old
 		#endif
 		]])],[
        	AC_MSG_RESULT(yes)
 		succeeded=yes
 		found_system=yes
       		],[
 	       	])
 		AC_LANG_POP([C++])
 	fi
 	if test "$succeeded" != "yes" ; then
 		if test "$_version" = "0" ; then
 			AC_MSG_ERROR([[We could not detect the boost libraries (version $boost_lib_version_req_shorten or higher). If you have a staged boost library (still not installed) please specify \$BOOST_ROOT in your environment and do not give a PATH to --with-boost option.  If you are sure you have boost installed, then check your version number looking in <boost/version.hpp>. See http://randspringer.de/boost for more documentation.]])
 		else
 			AC_MSG_ERROR([Your boost libraries seems to old (version $_version).])
 		fi
 	else
 		AC_SUBST(BOOST_CPPFLAGS)
 		AC_SUBST(BOOST_LDFLAGS)
 		AC_DEFINE(HAVE_BOOST,,[define if the Boost library is available])
 	fi
        CPPFLAGS="$CPPFLAGS_SAVED"
       	LDFLAGS="$LDFLAGS_SAVED"
 fi
 ])
@@ -1,140 +0,0 @@
 dnl aclocal.m4 generated automatically by aclocal 1.4
 dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 dnl This program is distributed in the hope that it will be useful,
 dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 dnl PARTICULAR PURPOSE.
 # Do all the work for Automake.  This macro actually does too much --
 # some checks are only needed if your package does certain things.
 # But this isn't really a big deal.
 # serial 1
 dnl Usage:
 dnl AM_INIT_AUTOMAKE(package,version, [no-define])
 AC_DEFUN(AM_INIT_AUTOMAKE,
 [AC_REQUIRE([AC_PROG_INSTALL])
 PACKAGE=[$1]
 AC_SUBST(PACKAGE)
 VERSION=[$2]
 AC_SUBST(VERSION)
 dnl test to see if srcdir already configured
 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
  AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
 fi
 ifelse([$3],,
 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))
 AC_REQUIRE([AM_SANITY_CHECK])
 AC_REQUIRE([AC_ARG_PROGRAM])
 dnl FIXME This is truly gross.
 missing_dir=`cd $ac_aux_dir && pwd`
 AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
 AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
 AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
 AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
 AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
 AC_REQUIRE([AC_PROG_MAKE_SET])])
 #
 # Check to make sure that the build environment is sane.
 #
 AC_DEFUN(AM_SANITY_CHECK,
 [AC_MSG_CHECKING([whether build environment is sane])
 # Just in case
 sleep 1
 echo timestamp > conftestfile
 # Do `set' in a subshell so we don't clobber the current shell's
 # arguments.  Must try -L first in case configure is actually a
 # symlink; some systems play weird games with the mod time of symlinks
 # (eg FreeBSD returns the mod time of the symlink's containing
 # directory).
 if (
   set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
   if test "[$]*" = "X"; then
      # -L didn't work.
      set X `ls -t $srcdir/configure conftestfile`
   fi
   if test "[$]*" != "X $srcdir/configure conftestfile" \
      && test "[$]*" != "X conftestfile $srcdir/configure"; then
      # If neither matched, then we have a broken ls.  This can happen
      # if, for instance, CONFIG_SHELL is bash and it inherits a
      # broken ls alias from the environment.  This has actually
      # happened.  Such a system could not be considered "sane".
      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
 alias in your environment])
   fi
   test "[$]2" = conftestfile
   )
 then
   # Ok.
   :
 else
   AC_MSG_ERROR([newly created file is older than distributed files!
 Check your system clock])
 fi
 rm -f conftest*
 AC_MSG_RESULT(yes)])
 dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)
 dnl The program must properly implement --version.
 AC_DEFUN(AM_MISSING_PROG,
 [AC_MSG_CHECKING(for working $2)
 # Run test in a subshell; some versions of sh will print an error if
 # an executable is not found, even if stderr is redirected.
 # Redirect stdin to placate older versions of autoconf.  Sigh.
 if ($2 --version) < /dev/null > /dev/null 2>&1; then
   $1=$2
   AC_MSG_RESULT(found)
 else
   $1="$3/missing $2"
   AC_MSG_RESULT(missing)
 fi
 AC_SUBST($1)])
 # Define a conditional.
 AC_DEFUN(AM_CONDITIONAL,
 [AC_SUBST($1_TRUE)
 AC_SUBST($1_FALSE)
 if $2; then
  $1_TRUE=
  $1_FALSE='#'
 else
  $1_TRUE='#'
  $1_FALSE=
 fi])
 # Like AC_CONFIG_HEADER, but automatically create stamp file.
 AC_DEFUN(AM_CONFIG_HEADER,
 [AC_PREREQ([2.12])
 AC_CONFIG_HEADER([$1])
 dnl When config.status generates a header, we must update the stamp-h file.
 dnl This file resides in the same directory as the config header
 dnl that is generated.  We must strip everything past the first ":",
 dnl and everything past the last "/".
 AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl
 ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>,
 <<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>,
 <<am_indx=1
 for am_file in <<$1>>; do
  case " <<$>>CONFIG_HEADERS " in
  *" <<$>>am_file "*<<)>>
    echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx
    ;;
  esac
  am_indx=`expr "<<$>>am_indx" + 1`
 done<<>>dnl>>)
 changequote([,]))])
@@ -1,394 +0,0 @@
 dnl
 dnl originally from ncftp 2.3.0
 dnl added wi_EXTRA_PDIR and wi_ANSI_C
 dnl $Id$
 dnl
 AC_DEFUN(wi_EXTRA_IDIR, [
 incdir="$1"
 if test -r $incdir ; then
 	case "$CPPFLAGS" in
 		*-I${incdir}*)
 			# echo "   + already had $incdir" 1>&6
 			;;
 		*)
 			if test "$CPPFLAGS" = "" ; then
 				CPPFLAGS="-I$incdir"
 			else
 				CPPFLAGS="$CPPFLAGS -I$incdir"
 			fi
 			echo "   + found $incdir" 1>&6
 			;;
 	esac
 fi
 ])
 dnl
 dnl
 dnl
 dnl
 AC_DEFUN(wi_EXTRA_LDIR, [
 mylibdir="$1"
 if test -r $mylibdir ; then
 	case "$LDFLAGS" in
 		*-L${mylibdir}*)
 			# echo "   + already had $mylibdir" 1>&6
 			;;
 		*)
 			if test "$LDFLAGS" = "" ; then
 				LDFLAGS="-L$mylibdir"
 			else
 				LDFLAGS="$LDFLAGS -L$mylibdir"
 			fi
 			echo "   + found $mylibdir" 1>&6
 			;;
 	esac
 fi
 ])
 dnl
 dnl __FP__
 dnl
 dnl
 AC_DEFUN(wi_EXTRA_PDIR, [
 progdir="$1"
 if test -r $progdir ; then
 	case "$PATH" in
 		*:${progdir}*)
 			# echo "   + already had $progdir" 1>&6
 			;;
 		*${progdir}:*)
 			# echo "   + already had $progdir" 1>&6
 			;;
 		*)
 			if test "$PATH" = "" ; then
 				PATH="$progdir"
 			else
 				PATH="$PATH:$progdir"
 			fi
 			echo "   + found $progdir" 1>&6
 			;;
 	esac
 fi
 ])
 dnl
 dnl
 dnl If you want to also look for include and lib subdirectories in the
 dnl $HOME tree, you supply "yes" as the first argument to this macro.
 dnl
 dnl If you want to look for subdirectories in include/lib directories,
 dnl you pass the names in argument 3, otherwise pass a dash.
 dnl
 AC_DEFUN(wi_EXTRA_DIRS, [echo "checking for extra include and lib directories..." 1>&6
 ifelse([$1], yes, [dnl
 b1=`cd .. ; pwd`
 b2=`cd ../.. ; pwd`
 exdirs="$HOME $j $b1 $b2 $prefix $2"
 ],[dnl
 exdirs="$prefix $2"
 ])
 subexdirs="$3"
 if test "$subexdirs" = "" ; then
 	subexdirs="-"
 fi
 for subexdir in $subexdirs ; do
 if test "$subexdir" = "-" ; then
 	subexdir=""
 else
 	subexdir="/$subexdir"
 fi
 for exdir in $exdirs ; do
 	if test "$exdir" != "/usr" || test "$subexdir" != ""; then
 		incdir="${exdir}/include${subexdir}"
 		wi_EXTRA_IDIR($incdir)
 		mylibdir="${exdir}/lib${subexdir}"
 		wi_EXTRA_LDIR($mylibdir)
 		progdir="${exdir}/bin${subexdirr}"
 		wi_EXTRA_PDIR($progdir)
 	fi
 done
 done
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_HPUX_CFLAGS,
 [AC_MSG_CHECKING(if HP-UX ansi C compiler flags are needed)
 AC_REQUIRE([AC_PROG_CC])
 os=`uname -s | tr '[A-Z]' '[a-z]'`
 ac_cv_hpux_flags=no
 if test "$os" = hp-ux ; then
 	if test "$ac_cv_prog_gcc" = yes ; then
 		if test "$CFLAGS" != "" ; then
 			# Shouldn't be in there.
 			CFLAGS=`echo "$CFLAGS" | sed 's/-Aa//g'`
 		fi
 	else
 		# If you're not using gcc, then you better have a cc/c89
 		# that is usable.  If you have the barebones compiler, it
 		# won't work.  The good compiler uses -Aa for the ANSI
 		# compatible stuff.
 		x=`echo $CFLAGS | grep 'Aa' 2>/dev/null`
 		if test "$x" = "" ; then
 			CFLAGS="$CFLAGS -Aa"
 		fi
 		ac_cv_hpux_flags=yes
 	fi
 	# Also add _HPUX_SOURCE to get the extended namespace.
 	x=`echo $CFLAGS | grep '_HPUX_SOURCE' 2>/dev/null`
 	if test "$x" = "" ; then
 		CFLAGS="$CFLAGS -D_HPUX_SOURCE"
 	fi
 fi
 AC_MSG_RESULT($ac_cv_hpux_flags)
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_CFLAGS, [AC_REQUIRE([AC_PROG_CC])
 wi_HPUX_CFLAGS
 	if test "$CFLAGS" = "" ; then
 		CFLAGS="-O"
 	elif test "$ac_cv_prog_gcc" = "yes" ; then
 		case "$CFLAGS" in
 			*"-g -O"*)
 				#echo "using -g as default gcc CFLAGS" 1>&6
 				CFLAGS=`echo $CFLAGS | sed 's/-g\ -O/-O/'`
 				;;
 			*"-O -g"*)
 				# Leave the -g, but remove all -O options.
 				#echo "using -g as default gcc CFLAGS" 1>&6
 				CFLAGS=`echo $CFLAGS | sed 's/-O\ -g/-O/'`
 				;;
 		esac
 	fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_PROTOTYPES, [
 AC_MSG_CHECKING(if the compiler supports function prototypes)
 AC_TRY_COMPILE(,[extern void exit(int status);],[wi_cv_prototypes=yes
 AC_DEFINE(PROTOTYPES)],wi_cv_prototypes=no)
 AC_MSG_RESULT($wi_cv_prototypes)
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_ANSI_C, [
 AC_MSG_CHECKING(ANSI-style function definitions)
 AC_TRY_COMPILE(,[int blubb(int x) { return 0; }],[wi_cv_ansi_funcs=yes
 AC_DEFINE(ANSI_FUNCS)],wi_cv_ansi_funcs=no)
 AC_MSG_RESULT($wi_cv_ansi_funcs)
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_HEADER_SYS_SELECT_H, [
 # See if <sys/select.h> is includable after <sys/time.h>
 if test "$ac_cv_header_sys_time_h" = no ; then
 AC_CHECK_HEADERS(sys/time.h sys/select.h)
 else
 AC_CHECK_HEADERS(sys/select.h)
 fi
 if test "$ac_cv_header_sys_select_h" = yes ; then
 	AC_MSG_CHECKING([if <sys/select.h> is compatible with <sys/time.h>])
 	selecth=yes
 	if test "$ac_cv_header_sys_time_h" = yes ; then
 		AC_TRY_COMPILE([#include <sys/time.h>
 		#include <sys/select.h>],[
 		fd_set a;
 		struct timeval tmval;
 		tmval.tv_sec = 0;],selecth=yes,selecth=no)
 		if test "$selecth" = yes ; then
 			AC_DEFINE(CAN_USE_SYS_SELECT_H)
 		fi
 	fi
 	AC_MSG_RESULT($selecth)
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_LIB_RESOLV, [
 # See if we could access two well-known sites without help of any special
 # libraries, like resolv.
 AC_TRY_RUN([
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 main()
 {
 	struct hostent *hp1, *hp2;
 	int result;
 	hp1 = gethostbyname("gatekeeper.dec.com");
 	hp2 = gethostbyname("ftp.ncsa.uiuc.edu");
 	result = ((hp1 != (struct hostent *) 0) && (hp2 != (struct hostent *) 0));
 	exit(! result);
 }],look_for_resolv=no,look_for_resolv=yes,look_for_resolv=yes)
 AC_MSG_CHECKING([if we need to look for -lresolv])
 AC_MSG_RESULT($look_for_resolv)
 if test "$look_for_resolv" = yes ; then
 AC_CHECK_LIB(resolv,main)
 else
 	ac_cv_lib_resolv=no
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_LIB_NSL, [
 AC_MSG_CHECKING(if we can use -lnsl)
 ac_save_LIBS="$LIBS";
 LIBS="$LIBS -lnsl";
 AC_CACHE_VAL(r_cv_use_libnsl, [
 AC_TRY_RUN(
 main() { if (getpwuid(getuid())) exit(0); exit(-1); },
 nc_cv_use_libnsl=yes, nc_cv_use_libnsl=no, nc_cv_use_libnsl=no)
 ])
 if test "$nc_cv_use_libnsl" = "no"; then LIBS="$ac_save_LIBS"; fi
 AC_MSG_RESULT($nc_cv_use_libnsl)
 ])dnl
 dnl
 dnl
 dnl
 AC_DEFUN(nc_PATH_PROG_ZCAT, [
 AC_PATH_PROG(GZCAT,gzcat)
 AC_PATH_PROG(ZCAT,zcat)
 if test "x$GZCAT" = x ; then
 	if test "x$ZCAT" != x ; then
 		# See if zcat is really gzcat.  gzcat has a --version option, regular
 		# zcat does not.
 		AC_MSG_CHECKING(if zcat is really gzcat in disguise)
 		if $ZCAT --version 2> /dev/null ; then
 			AC_DEFINE_UNQUOTED(GZCAT, "$ZCAT")
 			AC_MSG_RESULT(yes)
 		else
 			AC_MSG_RESULT(no)
 		fi
 	fi
 else
 	AC_DEFINE_UNQUOTED(GZCAT, "$GZCAT")
 fi
 if test "x$ZCAT" != x ; then
 	AC_DEFINE_UNQUOTED(ZCAT, "$ZCAT")
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_SYSV_EXTRA_DIRS, [
 # Use System V because their curses extensions are required.  This must
 # be done early so we use the -I and -L in the library checks also.
 # This is mostly a Solaris/SunOS hack.  Note that doing this will also
 # use all of the other System V libraries and headers.
 AC_MSG_CHECKING(for alternative System V libraries)
 if test -f /usr/5include/curses.h ; then
 	CPPFLAGS="$CPPFLAGS -I/usr/5include"
 	LDFLAGS="$LDFLAGS -L/usr/5lib"
 	AC_MSG_RESULT(yes)
 else
 	AC_MSG_RESULT(no)
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_DEFINE_UNAME, [
 # Get first 127 chars of all uname information.  Some folks have
 # way too much stuff there, so grab only the first 127.
 unam=`uname -a 2>/dev/null | cut -c1-127`
 if test "$unam" != "" ; then
 	AC_DEFINE_UNQUOTED(UNAME, "$unam")
 fi
 ])
 dnl
 dnl
 dnl
 AC_DEFUN(wi_READLINE_WITH_NCURSES, [
 # Readline and Ncurses could both define "backspace".
 # Warn about this if we have both things in our definitions list.
 if test "$ac_cv_lib_readline" = yes && test "$ac_cv_lib_ncurses" = yes ; then
 AC_MSG_CHECKING(if readline and ncurses will link together)
 j="$LIBS"
 LIBS="-lreadline -lncurses"
 AC_TRY_LINK(,[
 readline("prompt");
 endwin();
 ],k=yes,k=no)
 if test "$k" = no ; then
 	AC_MSG_RESULT(no)
 	# Remove '-lreadline' from LIBS.
 	LIBS=`echo $j | sed s/-lreadline//g`
 	ac_cv_lib_readline=no
 	AC_WARN([The versions of GNU readline and ncurses you have installed on this system
 can't be used together, because they use the same symbol, backspace. If
 possible, recompile one of the libraries with -Dbackspace=back_space, then
 re-run configure.])
 else
 	AC_MSG_RESULT(yes)
 	LIBS="$j"
 fi
 fi
 ])
 dnl
 dnl
 dnl
 dnl AC_EXT_DAYLIGHT
 dnl Check for an external variable daylight. Stolen from w3c-libwww.
 AC_DEFUN(AC_EXT_DAYLIGHT,
 [ AC_MSG_CHECKING(int daylight variable)
 AC_TRY_COMPILE([#include <time.h>], [return daylight;],
  have_daylight=yes,
  have_daylight=no)
 AC_MSG_RESULT($have_daylight)
 ])dnl
 dnl AC_EXT_TIMEZONE
 dnl Check for an external variable timezone. Stolen from tcl-8.0.
 AC_DEFUN(AC_EXT_TIMEZONE,
 [
 #
 # Its important to include time.h in this check, as some systems (like convex)
 # have timezone functions, etc.
 #
 have_timezone=no
 AC_MSG_CHECKING([long timezone variable])
 AC_TRY_COMPILE([#include <time.h>],
        [extern long timezone;
         timezone += 1;
         exit (0);],
        [have_timezone=yes
         AC_MSG_RESULT(yes)],
         AC_MSG_RESULT(no))
 #
 # On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
 #
 if test "$have_timezone" = no; then
   AC_MSG_CHECKING([time_t timezone variable])
   AC_TRY_COMPILE([#include <time.h>],
        [extern time_t timezone;
         timezone += 1;
         exit (0);],
        [have_timezone=yes
         AC_MSG_RESULT(yes)],
         AC_MSG_RESULT(no))
 fi
 ])dnl
@@ -0,0 +1,38 @@
 type = StaticLibrary,Multithreaded,
 exclude_dir = threads
 include_path = .
 include_path = ..
 include_path = .\SimGear
 include_path = ..\zlib-1.2.3
 include_path = "..\OpenAL 1.0 Software Development Kit\include"
 define = _USE_MATH_DEFINES
 define = _CRT_SECURE_NO_DEPRECATE
 define = HAVE_CONFIG_H
 # Rule to create simgear_config.h
 add_source_file = SOURCE=.\simgear\simgear_config.h.vc5\
 \
 !IF  "$(CFG)" == "SimGear - Win32 Release"\
 \
 # Begin Custom Build - Creating config.h\
 InputPath=.\simgear\simgear_config.h.vc5\
 \
 ".\simgear\simgear_config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\
        copy .\simgear\simgear_config.h.vc5 .\simgear\simgear_config.h\
 \
 # End Custom Build\
 \
 !ELSEIF  "$(CFG)" == "SimGear - Win32 Debug"\
 \
 # Begin Custom Build - Creating config.h\
 InputPath=.\simgear\simgear_config.h.vc5\
 \
 ".\simgear\simgear_config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\
        copy .\simgear\simgear_config.h.vc5 .\simgear\simgear_config.h\
 \
 # End Custom Build\
 \
 !ENDIF\
@@ -0,0 +1,52 @@
 #!/bin/sh
 OSTYPE=`uname -s`
 MACHINE=`uname -m`
 AUTO_MAKE_VERSION=`automake --version | head -1 | awk '{print $4}' | sed -e 's/\.\([0-9]*\).*/\1/'`
 if test $AUTO_MAKE_VERSION -lt 15; then
    echo ""
    echo "You need to upgrade to automake version 1.5 or greater."
    echo "Most distributions have packages available to install or you can"
    echo "find the source for the most recent version at"
    echo "ftp://ftp.gnu.org/gnu/automake"
    exit 1
 fi
 echo "Host info: $OSTYPE $MACHINE"
 echo -n " automake: `automake --version | head -1 | awk '{print $4}'`"
 echo " ($AUTO_MAKE_VERSION)"
 echo ""
 echo "Running aclocal"
 aclocal
 echo "Running autoheader"
 autoheader
 if [ ! -e simgear/simgear_config.h.in ]; then
    echo "ERROR: autoheader didn't create simgear/simgear_config.h.in!"
    exit 1
 fi    
 echo "Running automake --add-missing"
 automake --add-missing
 echo "Running autoconf"
 autoconf
 if [ ! -e configure ]; then
    echo "ERROR: configure was not created!"
    exit 1
 fi
 echo ""
 echo "======================================"
 if [ -f config.cache ]; then
    echo "config.cache exists.  Removing the config.cache file will force"
    echo "the ./configure script to rerun all it's tests rather than using"
    echo "the previously cached values."
    echo ""
 fi
 echo "Now you are ready to run './configure'"
 echo "======================================"
@@ -0,0 +1,638 @@
 dnl Process this file with autoget.sh to produce a working configure
 dnl script.
 AC_INIT
 AC_CONFIG_SRCDIR([simgear/bucket/newbucket.cxx])
 dnl Require at least automake 2.52
 AC_PREREQ(2.52)
 dnl Initialize the automake stuff
 AM_INIT_AUTOMAKE(SimGear, 1.9.1)
 dnl Specify KAI C++ compiler and flags.
 dnl Borrowed with slight modification from blitz distribution.
 AC_ARG_WITH(cxx,
  [  --with-cxx=COMPILER[:name-flags] set options for COMPILER (KCC)],
  [case "$withval" in
    KCC*)    # KAI C++ http://www.kai.com/
      echo "Configuring for KAI C++"
      AC_SG_SET_COMPILER($withval,"KCC","--restrict --strict_warnings")
      CXX_OPTIMIZE_FLAGS=="+K3 -O3"
      CXX_DEBUG_FLAGS="-g +K0"
    ;;
  esac
 ])
 AC_MSG_CHECKING([CXX])
 AC_MSG_RESULT([$CXX])
 AC_MSG_CHECKING([CC])
 AC_MSG_RESULT([$CC])
 dnl Checks for programs.
 AC_PROG_MAKE_SET
 AC_PROG_CC
 AC_PROG_CPP
 AC_PROG_CXX
 AC_PROG_RANLIB
 AC_PROG_INSTALL
 AC_PROG_LN_S
 AX_BOOST_BASE([1.37.0])
 if test "x$BOOST_CPPFLAGS" != "x-I/usr/include" ; then
   CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
 fi
 dnl set the $host variable based on local machine/os
 AC_CANONICAL_HOST
 dnl Used on the Irix platform
 case "${host}" in
 *-*-irix*)
    if test "x$CXX" = "xCC" -o "x$CXX" = "xccache CC"; then
        AR="$CXX -ar"
        ARFLAGS="-o"
        CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility/MIPSpro740"
        compatibility_DIR="compatibility"
        MIPSpro_DIRS="MIPSpro740"
        AC_MSG_CHECKING([for MIPSpro compiler version 7.4 or newer])
        AC_TRY_RUN([
           int main() {
              if ( _COMPILER_VERSION < 740 ) {
                 return -1;
              }
              return 0;
           }
        ], AC_MSG_RESULT(yes),
        [  AC_MSG_RESULT(no)
           CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility/MIPSpro721"
           MIPSpro_DIRS="$(MIPSpro_DIRS) MIPSpro721"
           AC_MSG_WARN([Using our own subset of the STL headers])
        ], AC_MSG_RESULT(yes))
        AC_SUBST(MIPSpro_DIRS)
    fi
    ;;
 *)
    AR="ar"
    ARFLAGS="cru"
    compatibility_DIR=
    ;;
 esac
 AC_SUBST(AR)
 AC_SUBST(ARFLAGS)
 AC_SUBST(compatibility_DIR)
 if echo $includedir | egrep "simgear$" > /dev/null; then
    echo "includedir is" $includedir "libdir is" $libdir
 else
    includedir="${includedir}/simgear"
    echo "includedir changed to" $includedir "libdir is" $libdir
 fi
 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])
 fi
 # Specify if we want to build with Norman's jpeg image server support.
 # This requires libjpeg to be installed and available.
 # Default to with_jpeg_server=no
 JPEGLIB=''
 AC_ARG_WITH(jpeg_factory, [  --with-jpeg-factory     Include Norman's jpeg image factory support code])
 if test "x$with_jpeg_factory" = "xyes" ; then
    echo "Building with Norman's jpeg image factory support"
    AC_CHECK_LIB(jpeg, jpeg_start_compress)
    if test "x$ac_cv_lib_jpeg_jpeg_start_compress" != "xyes" ; then
        echo
        echo "In order to build the jpeg factory code you need libjpeg installed."
        echo "otherwise please configure with the --with-jpeg-sever=no option"
        echo
        echo "libjpeg is available at :"
        echo "  ftp://ftp.uu.net in the directory graphics/jpeg"
        exit 1
    fi
 else
    echo "Building without Norman's jpeg image server support"
 fi
 AM_CONDITIONAL(ENABLE_JPEG_SERVER, test "x$with_jpeg_factory" = "xyes")
 # specify the plib location
 AC_ARG_WITH(plib, [  --with-plib=PREFIX      Specify the prefix path to plib])
 if test "x$with_plib" != "x" ; then
    echo "plib prefix is $with_plib"
    EXTRA_DIRS="${EXTRA_DIRS} $with_plib"
 fi
 AC_ARG_WITH(plib_framework, [ --with-plib-framework=PREFIX      Specify the prefix path to PLIB.framework ])
 if test "x$with_plib_framework" != "x"; then
    echo "plib framework prefix is $with_plib_framework"
 fi
 # specify the osg location
 AC_ARG_WITH(osg, [  --with-osg=PREFIX       Specify the prefix path to osg])
 if test "x$with_osg" != "x" ; then
    echo "osg prefix is $with_osg"
    EXTRA_DIRS="${EXTRA_DIRS} $with_osg"
 fi
 AC_ARG_WITH(osg_framework, [ --with-osg-framework=PREFIX      Specify the prefix path to OSG.framework ])
 if test "x$with_osg_framework" != "x"; then
    echo "osg framework prefix is $with_osg_framework"
    CPPFLAGS = "$CPPFLAGS -F$with-osg-framework"
    export DYLD_FRAMEWORK_PATH="$DYLD_FRAMEWORK_PATH:$with_osg_framework"
 fi
 dnl specifying OpenAL.framework (for user provided OpenAL.framework / ALUT)
 AC_ARG_WITH(openal_framework, [ --with-openal-framework=PREFIX    Speicfy the prefix path to OpenAL.framework ])
 if test "x$with_openal_framework" != "x"; then
    echo "OpenAL framework prefix is $with_openal_framework"
 fi
 dnl Determine an extra directories to add to include/lib search paths
 case "${host}" in
 *-apple-darwin* | *-*-cygwin* | *-*-mingw32*)
    echo no EXTRA_DIRS for $host
    ;;
 *)
    if test -d /usr/X11R6 ; then
        EXTRA_DIR1="/usr/X11R6"
    fi
    if test -d /opt/X11R6 ; then
        EXTRA_DIR2="/opt/X11R6"
    fi
    EXTRA_DIRS="${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
 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 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
    ;;
 esac
 dnl Checks for libraries.
 dnl Thread related checks
 AC_CHECK_HEADER(pthread.h)
 AC_SEARCH_LIBS(pthread_exit, [pthread c_r])
 if test "x$ac_cv_header_pthread_h" = "xyes"; then
    CXXFLAGS="$CXXFLAGS -D_REENTRANT"
    CFLAGS="$CFLAGS -D_REENTRANT"
  if test "x$ac_cv_search_pthread_exit" = "x-lc_r"; then
    CXXFLAGS="-pthread $CXXFLAGS"
    CFLAGS="-pthread $CFLAGS"
  fi
 fi
 AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_header_pthread_h" = "xyes")
 thread_LIBS="$LIBS"
 LIBS=""
 dnl search for network related libraries
 AC_SEARCH_LIBS(inet_addr, xnet)
 AC_SEARCH_LIBS(socket, socket)
 network_LIBS="$LIBS"
 LIBS=""
 dnl check for some default libraries
 AC_SEARCH_LIBS(cos, m)
 AC_SEARCH_LIBS(clock_gettime, rt)
 base_LIBS="$LIBS"
 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 -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 OpenGL -framework Carbon -lobjc"
    ;;
 *)
    dnl X-Windows based machines
    AC_SEARCH_LIBS(XCreateWindow, X11)
    AC_SEARCH_LIBS(XShmCreateImage, Xext)
    AC_SEARCH_LIBS(XGetExtensionVersion, Xi)
    AC_SEARCH_LIBS(IceOpenConnection, ICE)
    AC_SEARCH_LIBS(SmcOpenConnection, SM)
    AC_SEARCH_LIBS(XtMalloc, Xt)
    AC_SEARCH_LIBS(XmuLookupStandardColormap, Xmu)
    AC_SEARCH_LIBS(glNewList, [ GL GLcore MesaGL ])
    if test "x$ac_cv_search_glNewList" = "x-lGLcore"; then
 	dnl if GLcore found, then also check for GL
        AC_SEARCH_LIBS(glXCreateContext, GL)
    fi
    dnl if using mesa, check for xmesa.h
    if test "x$ac_cv_search_glNewList" = "x-lMesaGL"; then
 	AC_CHECK_HEADER(GL/fxmesa.h)
 	if test "x$ac_cv_header_GL_fxmesa_h" = "xyes"; then
 	    AC_DEFINE([XMESA], 1, [Define for fxmesa])
            AC_DEFINE([FX], 1, [Define for fxmesa])
        fi
    fi
    AC_SEARCH_LIBS(gluLookAt, [ GLU MesaGLU ])
    ;;
 esac
 AC_SEARCH_LIBS(glutGetModifiers, [ glut glut32 freeglut ], have_glut=yes, have_glut=no)
 AM_CONDITIONAL(HAVE_GLUT, test "x$have_glut" = "xyes")
 opengl_LIBS="$LIBS"
 LIBS="$base_LIBS"
 dnl check for OpenAL libraries
 OPENAL_OK="no"
 ALUT_OK="no"
 case "${host}" in
 *-*-cygwin* | *-*-mingw32*)
    dnl CygWin under Windoze.
    INCLUDES="$INCLUDES -I/usr/local/include/"
    LIBS="$LIBS -L/usr/local/lib"
    AC_SEARCH_LIBS(alGenBuffers, [ openal32 openal ] )
    AC_SEARCH_LIBS(alutInit, [ openal32 ALut alut ] )
    LIBS="$LIBS -lwinmm -ldsound -ldxguid -lole32"
    openal_LIBS="$LIBS"
    OPENAL_OK="$ac_cv_search_alGenBuffers"
    ALUT_OK="$ac_cv_search_alutInit"
    ;;
 *-apple-darwin*)
    dnl Mac OS X
    LIBS="$LIBS -framework IOKit -framework OpenAL"
    openal_LIBS="$LIBS"
    OPENAL_OK="yes"
    ALUT_OK="no"
    if test "x$with_openal_lib" != "x"; then
        echo "libopenal is not supported on Mac OS platform."
        openal_LIBS=""
    fi
    OPENAL_OK="yes"
    # Looking for alut.h, if found assume that it is a part of
    # the OpenAL package.
    AC_CHECK_HEADERS([OpenAL/alut.h],[ALUT_OK="yes"])
    dnl Thank you Christian Bauer from SheepSaver
    dnl Modified by Tatsuhiro Nishioka for accepting a given framework path
    dnl AC_CHECK_FRAMEWORK($1=NAME, $2=INCLUDES, $3=FRAMEWORK_PATH) ; $3 is optional
    AC_DEFUN([AC_CHECK_FRAMEWORK], [
    AS_VAR_PUSHDEF([ac_Framework], [ac_cv_framework_$1])dnl
    AC_CACHE_CHECK([whether compiler supports framework $1],
        ac_Framework, [
        saved_LIBS="$LIBS"
        FRAMEWORKS="$FRAMEWORKS -framework $1"
        if test "$3" = ""; then
            FRAMEWORKS="$FRAMEWORKS $ADD2LD"
        elif test "`echo $FRAMEWORKS | grep -- -F$3`" = ""; then
            FRAMEWORKS="$FRAMEWORKS -F$3"
            CXXFLAGS="$CXXFLAGS -F$3"
            CCFLAGS="$CCFLAGS -F$3"
            dnl This is needed for AC_TRY_LINK when a framework path is specified
            export DYLD_FRAMEWORK_PATH="${DYLD_FRAMEWORK_PATH}:$3"
        fi
        AC_TRY_LINK(
        [$2], [],
        [AS_VAR_SET(ac_Framework, yes)], [AS_VAR_SET(ac_Framework, no); LIBS="$saved_LIBS"]
        )
    ])
    AS_IF([test AS_VAR_GET(ac_Framework) = yes],
        [AC_DEFINE(AS_TR_CPP(HAVE_FRAMEWORK_$1), 1, [Define if framework $1 is available.])]
    )
    AS_VAR_POPDEF([ac_Framework])dnl
    ])
    dnl Check for OpenAL.framework when --with-openal-framework is specified
    dnl Of cource OpenAL.framework needs to have alut.h 
    if test "x$with_openal_framework" != "x"; then
      AC_CHECK_FRAMEWORK(OpenAL, [#include <OpenAL/alut.h>], $with_openal_framework)
    fi
    ;;
 *)
    dnl default unix style machines
    save_LIBS=$LIBS
    LIBS="$LIBS $thread_LIBS"
    AC_SEARCH_LIBS(alGenBuffers, openal)
    AC_SEARCH_LIBS(alutInit, [ alut openal ] )
    OPENAL_OK="$ac_cv_search_alGenBuffers"
    ALUT_OK="$ac_cv_search_alutInit"
    openal_LIBS="$LIBS"
    LIBS=$save_LIBS
    ;;
 esac
 if test "$OPENAL_OK" == "no"; then
    echo
    echo "You *must* have the openal library installed on your system to build"
    echo "SimGear!"
    echo
    echo "Please see README.OpenAL for more details."
    echo
    echo "configure aborted."
    exit
 fi
 if test "$ALUT_OK" == "no"; then
    echo
    echo "You *must* have the alut library installed on your system to build"
    echo "SimGear!"
    echo
    echo "Please see README.OpenAL for more details."
    echo
    echo "configure aborted."
    exit
 fi
 LIBS="$base_LIBS"
 AC_SUBST(base_LIBS)
 AC_SUBST(openal_LIBS)
 AC_SUBST(opengl_LIBS)
 AC_SUBST(thread_LIBS)
 AC_SUBST(network_LIBS)
 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
 CXXCPP="g++ -E"
 AC_LANG_PUSH(C++)
 dnl Check for "plib" without which we cannot go on
 case ${host} in 
 *-apple-darwin*)
    # Check PLIB framework availability when with-plib-framework is specified 
    if test "x$with_plib_framework" != "x"; then
        AC_CHECK_FRAMEWORK(PLIB, [#include <plib/ul.h>], $with_plib_framework)
        plib_FRAMEWORK="$FRAMEWORKS"
        FRAMEWORKS=""
        AC_SUBST(plib_FRAMEWORK)
    fi
    ;;
 esac
 AM_CONDITIONAL(HAVE_FRAMEWORK_PLIB, test "x$ac_cv_framework_PLIB" != "x")
 AC_CHECK_HEADER(plib/ul.h)
 if test "x$ac_cv_header_plib_ul_h" != "xyes"; then
    echo
    echo "You *must* have the plib library installed on your system to build"
    echo "SimGear!"
    echo
    echo "Please see README.plib for more details."
    echo
    echo "configure aborted."
    exit
 fi
 AC_MSG_CHECKING([for plib 1.8.5 or newer])
 AC_TRY_RUN([
 #include <plib/ul.h>
 #define MIN_PLIB_VERSION 185
 int main() {
    if ( PLIB_VERSION < MIN_PLIB_VERSION ) {
 	 return -1;
    }
    return 0;
 }
 ],
  AC_MSG_RESULT(yes),
  [AC_MSG_RESULT(wrong version);
   AC_MSG_ERROR([Install plib 1.8.5 or later first...])],
  AC_MSG_RESULT(yes)
 )
 LIBS="$saved_LIBS"
 # OpenSceneGraph
 case "${host}" in
 *-apple-darwin*)
    if test "x$with_osg_framework" != "x"; then
        AC_CHECK_FRAMEWORK(osgViewer, [#include <osgViewer/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgGA, [#include <osgGA/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgText, [#include <osgText/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgFX, [#include <osgFX/AnisotropicLighting>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgUtil, [#include <osgUtil/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgDB, [#include <osgDB/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgSim, [#include <osgSim/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osgParticle, [#include <osgParticle/Version>], $with_osg_framework)
        AC_CHECK_FRAMEWORK(osg, [#include <osg/Version>], $with_osg_framework)
        osg_FRAMEWORKS="$FRAMEWORKS"
        FRAMEWORKS=""
        AC_SUBST(osg_FRAMEWORKS)
        AC_CHECK_FRAMEWORK(OpenThreads, [#include <OpenThreads/Version>], $with_osg_framework)
        openthreads_FRAMEWORK="$FRAMEWORKS"
        FRAMEWORKS=""
        AC_SUBST(openthreads_FRAMEWORK)
    else
        dnl
        dnl This is needed when osg dynamic libs are specified 
        dnl instead of OSG frameworks on Mac OS X
        dnl
        LDFLAGS="$LDFLAGS -L$with_osg"
    fi
    ;;
 esac
 AM_CONDITIONAL(HAVE_FRAMEWORK_OSG, test "x$ac_cv_framework_osg" != "x")
 AC_CHECK_HEADER(osg/Version)
 if test "x$ac_cv_header_osg_Version" != "xyes"; then
  if test "x$ac_cv_framework_osg" != "xyes"; then
    echo
    echo "You *must* have the OpenSceneGraph support library installed on your system"
    echo "to build this version of SimGear!"
    echo
    echo "Please see README.OSG for more details."
    echo
    echo "configure aborted."
    exit
  fi
 fi
 AC_CHECK_HEADER(boost/version.hpp)
 if test "x$ac_cv_header_boost_version_hpp" != "xyes"; then
    echo
    echo "You *must* have the Boost library installed on your system"
    echo "to build this version of SimGear!"
    echo
    echo "configure aborted."
    exit
 fi
 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 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 values.h )
 if test "x$ac_cv_header_stdint_h" = "xyes"; then
    AC_DEFINE([HAVE_STDINT_H], 1, [Define if stdint.h exists])
 fi
 dnl Checks for typedefs, structures, and compiler characteristics.
 AC_C_CONST
 AC_TYPE_SIZE_T
 AC_TYPE_MODE_T
 AC_HEADER_TIME
 AC_STRUCT_TM
 dnl Checks for library functions.
 old_LIBS=$LIBS
 LIBS="$base_LIBS $network_LIBS $opengl_LIBS"
 AC_TYPE_SIGNAL
 AC_FUNC_VPRINTF
 AC_CHECK_FUNCS( [ \
        ftime gettimeofday timegm memcpy bcopy mktime strstr rand \
 	random drand48 setitimer getitimer signal GetLocalTime rint getrusage ] )
 LIBS=$old_LIBS
 AM_CONFIG_HEADER(simgear/simgear_config.h)
 AC_CONFIG_FILES([ \
 	Makefile \
 	SimGear.spec \
 	simgear/Makefile \
 	simgear/version.h \
 	simgear/compatibility/Makefile \
 	simgear/compatibility/MIPSpro721/Makefile \
 	simgear/compatibility/MIPSpro740/Makefile \
 	simgear/bucket/Makefile \
 	simgear/debug/Makefile \
 	simgear/ephemeris/Makefile \
 	simgear/io/Makefile \
 	simgear/magvar/Makefile \
 	simgear/math/Makefile \
 	simgear/environment/Makefile \
 	simgear/misc/Makefile \
 	simgear/nasal/Makefile \
 	simgear/props/Makefile \
 	simgear/route/Makefile \
 	simgear/scene/Makefile \
 	simgear/scene/bvh/Makefile \
 	simgear/scene/material/Makefile \
 	simgear/scene/model/Makefile \
 	simgear/scene/sky/Makefile \
 	simgear/scene/tgdb/Makefile \
 	simgear/scene/util/Makefile \
 	simgear/screen/Makefile \
 	simgear/serial/Makefile \
 	simgear/sound/Makefile \
 	simgear/structure/Makefile \
 	simgear/threads/Makefile \
 	simgear/timing/Makefile \
 	simgear/xml/Makefile \
 ])
 AC_OUTPUT
 echo ""
 echo "Configure Summary"
 echo "================="
 echo "Prefix: $prefix"
 if test "x$with_logging" != "x"; then
    echo "Debug messages: $with_logging"
 else
    echo "Debug messages: yes"
 fi
 echo -n "Automake version: "
 automake --version | head -1
 if test "x$with_jpeg_factory" = "xyes"; then
   echo "With JPEG Factory support"
 else
   echo "Without JPEG Factory support"
 fi
 if test "x$ac_cv_header_pthread_h" = "xyes"; then
   echo "Threads: pthread lib found."
 else
   echo "Threads: no threads (pthread lib not found.)"
 fi
@@ -1,288 +0,0 @@
 dnl Process this file with aclocal ; automake -a ; autoconf to produce a 
 dnl working configure script.
 dnl
 dnl $Id$
 AC_INIT(simgear/bucket/newbucket.cxx)
 dnl Initialize the automake stuff
 AM_INIT_AUTOMAKE(SimGear, 0.0.8)
 dnl Checks for programs.
 AC_PROG_MAKE_SET
 AC_PROG_CC
 AC_PROG_CXX
 AC_PROG_RANLIB
 AC_PROG_INSTALL
 AC_PROG_LN_S
 if echo $includedir | egrep "simgear$" > /dev/null; then
    echo "includedir is" $includedir "libdir is" $libdir
 else
    includedir="${includedir}/simgear"
    echo "includedir changed to" $includedir "libdir is" $libdir
 fi
 dnl Run configure in the gdbm subdir
 dnl AC_CONFIG_SUBDIRS( simgear/gdbm )
 dnl Specify if we want logging (testing build) or not (release build)
 # set logging default value
 # with_logging=yes
 AC_ARG_WITH(logging, [  --with-logging          Include logging output (default)])
 if test "x$with_logging" = "xno" ; then
    AC_DEFINE(FG_NDEBUG)
 fi
 dnl specify if we are building with "checker"
 AC_ARG_WITH(efence, [  --with-efence           Specify if we are building with "electric-fence"])
 if test "x$with_efence" = "xyes" ; then
    echo "Building with efence"
    LIBS= "$LIBS -lefence"
 fi
 dnl Check for MS Windows environment
 AC_CHECK_HEADER(windows.h)
 dnl extra library and include directories
 EXTRA_DIRS="/usr/local /usr/local/plib /usr/X11R6"
 if test -d /opt/X11R6 ; then
     EXTRA_DIRS="$EXTRA_DIRS /opt/X11R6"
 fi
 if test "x$ac_cv_header_windows_h" = "xyes" ; then
    EXTRA_DIRS="${EXTRA_DIRS} `pwd`/Win32"
 # elif test `uname -s` = "SunOS" ; then
 #   EXTRA_DIRS="${EXTRA_DIRS} `pwd`/SunOS"
 fi
 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
 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 Enable serial support on Unix type systems
 AM_CONDITIONAL(ENABLE_UNIX_SERIAL, true)
 dnl Check for X11 (fancy)
 AC_PATH_XTRA
 dnl Checks for libraries.
 null_LIBS="$LIBS"
 AC_CHECK_LIB(m, cos)
 base_LIBS="$LIBS"
 AC_CHECK_LIB(socket, socket)
 AC_CHECK_LIB(X11, XCreateWindow)
 AC_CHECK_LIB(Xext, XShmCreateImage)
 AC_CHECK_LIB(Xi, XGetExtensionVersion)
 AC_CHECK_LIB(ICE, IceOpenConnection)
 AC_CHECK_LIB(SM, SmcOpenConnection)
 AC_CHECK_LIB(Xt, XtMalloc)
 AC_CHECK_LIB(Xmu, XmuLookupStandardColormap)
 dnl check for OpenGL related libraries
 if test "x$ac_cv_header_windows_h" != "xyes" ; then
    dnl Reasonable stuff for non-windoze variants ... :-)
    AC_CHECK_LIB(GLcore, glNewList)
    if test "x$ac_cv_lib_GLcore_glNewList" = "xno" ; then
 	dnl if no GLcore, check for GL
 	AC_CHECK_LIB(GL, glNewList)
 	if test "x$ac_cv_lib_GL_glNewList" = "xno" ; then
 	    dnl if no GL, check for MesaGL
 	    AC_CHECK_LIB(MesaGL, glNewList)
 	fi
    else
 	dnl if GLcore found, then also check for GL
 	AC_CHECK_LIB(GL, glXCreateContext)
    fi
    dnl if using mesa, check for xmesa.h
    if test "x$ac_cv_lib_MesaGL_glNewList" = "xyes" ; then
 	AC_CHECK_HEADER(GL/xmesa.h)
 	if test "x$ac_cv_header_GL_xmesa_h" = "xyes"; then
 	    AC_DEFINE( XMESA )
            AC_DEFINE( FX )
        fi
    fi
    AC_CHECK_LIB(GLU, gluLookAt)
    if test "x$ac_cv_lib_GLU_gluLookAt" = "xno" ; then
 	dnl if no GLU, check for MesaGLU
 	AC_CHECK_LIB(MesaGLU, gluLookAt)
    fi
    dnl check for glut
    AC_CHECK_LIB(glut, glutGetModifiers)
    dnl test for glutGameModeString, but avoid adding glut a second time into
    dnl the list of libraries
    save_LIBS="$LIBS"
    AC_CHECK_LIB(glut, glutGameModeString)
    LIBS="$save_LIBS"
 else
    dnl Win32 is a little wierd because it has to try to handle the various
    dnl winbloze-isms.  We'll just do this manually for now.
    echo Win32 specific hacks...
    AC_DEFINE(WIN32)
    dnl force a failed check since we will be building under windoze
    AM_CONDITIONAL(ENABLE_XMESA_FX, test "no" = "yes")
    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"
    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 fetch and install the latest version of glut from:"
    echo
    echo "    http://reality.sgi.com/opengl/glut3/glut3.html"
    exit 1
 fi
 opengl_LIBS="$LIBS"
 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 "plib" without which we cannot go on
 AC_CHECK_HEADER(plib/pu.h)
 if test "x$ac_cv_header_plib_pu_h" != "xyes"; then
    echo
    echo "You *must* have the plib library installed on your system to build"
    echo "the FGFS simulator!"
    echo
    echo "Please see README.plib for more details."
    echo
    echo "configure aborted."
    exit
 fi
 dnl Check for system installed gdbm
 AC_CHECK_HEADER(gdbm.h)
 if test "x$ac_cv_header_gdbm_h" = "xyes"; then
    AC_DEFINE( HAVE_GDBM )
 else
    echo "no gdbm found, configuring and building."
 fi
 AM_CONDITIONAL(HAVE_GDBM, test "x$ac_cv_header_gdbm_h" = "xyes" )
 dnl Check for system installed zlib
 AC_CHECK_HEADER(zlib.h)
 if test "x$ac_cv_header_zlib_h" = "xyes"; then
    AC_DEFINE( HAVE_ZLIB )
 else
    echo "no zlib found, building."
 fi
 AM_CONDITIONAL(HAVE_ZLIB, test "x$ac_cv_header_zlib_h" = "xyes" )
 dnl Checks for header files.
 AC_HEADER_STDC
 AC_CHECK_HEADERS( \
 	fcntl.h getopt.h malloc.h memory.h stdlib.h sys/param.h sys/stat.h \
        sys/time.h sys/timeb.h unistd.h windows.h winbase.h values.h )
 dnl Checks for typedefs, structures, and compiler characteristics.
 AC_C_CONST
 AC_TYPE_SIZE_T
 AC_HEADER_TIME
 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 \
 	random setitimer getitimer signal GetLocalTime rint getrusage )
 AM_CONFIG_HEADER(simgear/config.h)
 AC_OUTPUT( \
 	Makefile \
 	SimGear.spec \
 	simgear/Makefile \
 	simgear/version.h \
 	simgear/bucket/Makefile \
 	simgear/debug/Makefile \
 	simgear/gdbm/Makefile \
 	simgear/magvar/Makefile \
 	simgear/math/Makefile \
 	simgear/misc/Makefile \
 	simgear/screen/Makefile \
 	simgear/serial/Makefile \
 	simgear/xgl/Makefile \
 	simgear/zlib/Makefile \
 )
 AC_OUTPUT_COMMANDS([
 	if test "x$ac_cv_header_windows_h" = "xyes" ; then
 		cp simgear/gdbm/autoconf.h.cygwin32 simgear/gdbm/autoconf.h
 	fi
 ])
 echo ""
 echo "Configure Summary"
 echo "================="
 echo "Prefix: $prefix"
 if test "x$with_logging" != "x"; then
    echo "Debug messages: $with_logging"
 else
    echo "Debug messages: yes"
 fi
 if test "x$with_efence" != "x"; then
    echo "Electric fence: $with_efence"
 else
    echo "Electric fence: no"
 fi
 if test "x$ac_cv_header_gdbm_h" != "xyes"; then
   echo "Building gdbm"
 fi
 if test "x$ac_cv_header_zlib_h" != "xyes"; then
   echo "Building zlib"
 fi
@@ -1,42 +0,0 @@
 #! /bin/sh
 echo ""
 echo "running $0 to rebuild simgear include links"
 # toast the old directory
 rm -rf src/simgear
 mkdir src/simgear
 mkdir src/simgear/bucket
 mkdir src/simgear/debug
 mkdir src/simgear/math
 mkdir src/simgear/misc
 mkdir src/simgear/screen
 mkdir src/simgear/serial
 mkdir src/simgear/xgl
 mkdir src/simgear/zlib
 # build new links
 ln -s ../include/compiler.h src/simgear/compiler.h
 ln -s ../include/constants.h src/simgear/constants.h
 ln -s ../include/fg_traits.hxx src/simgear/fg_traits.hxx
 ln -s ../include/fg_zlib.h src/simgear/fg_zlib.h
 ln -s ../include/version.h src/simgear/version.h
 ln -s ../../bucket/newbucket.hxx src/simgear/bucket/newbucket.hxx
 ln -s ../../debug/debug_types.h src/simgear/debug/debug_types.h
 ln -s ../../debug/logstream.hxx src/simgear/debug/logstream.hxx
 ln -s ../../math/fg_memory.h src/simgear/math/fg_memory.h
 ln -s ../../math/fg_types.hxx src/simgear/math/fg_types.hxx
 ln -s ../../math/point3d.hxx src/simgear/math/point3d.hxx
 ln -s ../../math/polar3d.hxx src/simgear/math/polar3d.hxx
 ln -s ../../misc/fgpath.hxx src/simgear/misc/fgpath.hxx
 ln -s ../../misc/fgstream.hxx src/simgear/misc/fgstream.hxx
 ln -s ../../misc/zfstream.hxx src/simgear/misc/zfstream.hxx
 ln -s ../../xgl/xgl.h src/simgear/xgl/xgl.h
 ln -s ../../zlib/zlib.h src/simgear/zlib/zlib.h
 ln -s ../../zlib/zconf.h src/simgear/zlib/zconf.h
@@ -0,0 +1,5 @@
 Debug
 Release
 SimGear.ncb
 SimGear.suo
 *.user
@@ -0,0 +1,21 @@
 Microsoft Visual Studio Solution File, Format Version 8.00
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear", "SimGear.vcproj", "{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}"
 	ProjectSection(ProjectDependencies) = postProject
 	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfiguration) = preSolution
 		Debug = Debug
 		Release = Release
 	EndGlobalSection
 	GlobalSection(ProjectConfiguration) = postSolution
 		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug.ActiveCfg = Debug|Win32
 		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug.Build.0 = Debug|Win32
 		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release.ActiveCfg = Release|Win32
 		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 	EndGlobalSection
 	GlobalSection(ExtensibilityAddIns) = postSolution
 	EndGlobalSection
 EndGlobal
@@ -0,0 +1,5 @@
 SimGear.ncb
 SimGear.suo
 *.user
 Win32
 x64
@@ -0,0 +1,8 @@
 Makefile
 Makefile.in
 simgear_config.h
 simgear_config.h.in
 stamp-h
 stamp-h.in
 stamp-h1
 version.h
@@ -1,38 +1,37 @@
-if ENABLE_UNIX_SERIAL
+if HAVE_THREADS
-SERIAL_DIRS = serial
+SGTHREAD_DIR = threads
 else
-SERIAL_DIRS =
+SGTHREAD_DIR = 
 endif
-if HAVE_GDBM
+# METAR_DIRS =
-GDBM_DIRS =
+METAR_DIRS = environment
 else
 GDBM_DIRS = gdbm
 endif
-if HAVE_ZLIB
+EXTRA_DIST = simgear_config.h.vc5 simgear_config.h-msvc71 version.h.in
 ZLIB_DIRS =
 else
 ZLIB_DIRS = zlib
 endif
-METAR_DIRS =
+include_HEADERS = \
-# METAR_DIRS = metar
+	compiler.h constants.h sg_inlines.h version.h
 EXTRA_DIST = version.h.in
 include_HEADERS = compiler.h constants.h fg_traits.hxx fg_zlib.h version.h
 SUBDIRS = \
-	bucket \
+	$(compatibility_DIR) \
 	xml \
 	debug \
-	$(GDBM_DIRS) \
+	misc \
 	structure \
 	bucket \
 	ephemeris \
 	io \
 	magvar \
 	math \
 	$(METAR_DIRS) \
-	misc \
+	nasal \
 	props \
 	route \
 	scene \
 	screen \
-	$(SERIAL_DIRS) \
+	serial \
-	xgl \
+	sound \
-	$(ZLIB_DIRS)
+	$(SGTHREAD_DIR) \
 	timing
 DIST_SUBDIRS = $(SUBDIRS) compatibility
@@ -0,0 +1,3 @@
 .deps
 Makefile
 Makefile.in
@@ -11,7 +11,7 @@ libsgbucket_a_SOURCES = newbucket.cxx
 # testbucket_SOURCES = testbucket.cxx
 # testbucket_LDADD = \
-# 	$(top_builddir)/bucket/libsgbucket.a \
+# 	libsgbucket.a \
 # 	$(top_builddir)/misc/libsgmisc.a
-INCLUDES += -I$(top_builddir)
+INCLUDES = -I$(top_srcdir)
@@ -3,40 +3,143 @@
 *
 * Written by Curtis L. Olson, started February 1999.
 *
- * Copyright (C) 1999  Curtis L. Olson - curt@flightgear.org
+ * Copyright (C) 1999  Curtis L. Olson - http://www.flightgear.org/~curt/
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifdef HAVE_CONFIG_H
-#  include <config.h>
+#  include <simgear_config.h>
 #endif
 #include <math.h>
-#include <simgear/misc/fgpath.hxx>
+#include <simgear/misc/sg_path.hxx>
 #include "newbucket.hxx"
 // default constructor
 SGBucket::SGBucket() {
 }
 // constructor for specified location
 SGBucket::SGBucket(const double dlon, const double dlat) {
    set_bucket(dlon, dlat);
 }
 SGBucket::SGBucket(const SGGeod& geod) {
    set_bucket(geod);
 }
 // create an impossible bucket if false
 SGBucket::SGBucket(const bool is_good) {
    set_bucket(0.0, 0.0);
    if ( !is_good ) {
 	lon = -1000;
    }
 }
 // Parse a unique scenery tile index and find the lon, lat, x, and y
 SGBucket::SGBucket(const long int bindex) {
    long int index = bindex;
    lon = index >> 14;
    index -= lon << 14;
    lon -= 180;
    lat = index >> 6;
    index -= lat << 6;
    lat -= 90;
    y = index >> 3;
    index -= y << 3;
    x = index;
 }
 // Set the bucket params for the specified lat and lon
 void SGBucket::set_bucket( double *lonlat ) {
    set_bucket( lonlat[0], lonlat[1] );
 }	
 // Set the bucket params for the specified lat and lon
 void SGBucket::set_bucket( double dlon, double dlat ) {
    //
    // latitude first
    //
    double span = sg_bucket_span( dlat );
    double diff = dlon - (double)(int)dlon;
    // cout << "diff = " << diff << "  span = " << span << endl;
    if ( (dlon >= 0) || (fabs(diff) < SG_EPSILON) ) {
 	lon = (int)dlon;
    } else {
 	lon = (int)dlon - 1;
    }
    // find subdivision or super lon if needed
    if ( span < SG_EPSILON ) {
 	// polar cap
 	lon = 0;
 	x = 0;
    } else if ( span <= 1.0 ) {
 	x = (int)((dlon - lon) / span);
    } else {
 	if ( dlon >= 0 ) {
 	    lon = (int)( (int)(lon / span) * span);
 	} else {
 	    // cout << " lon = " << lon 
 	    //  << "  tmp = " << (int)((lon-1) / span) << endl;
 	    lon = (int)( (int)((lon + 1) / span) * span - span);
 	    if ( lon < -180 ) {
 		lon = -180;
 	    }
 	}
 	x = 0;
    }
    //
    // then latitude
    //
    diff = dlat - (double)(int)dlat;
    if ( (dlat >= 0) || (fabs(diff) < SG_EPSILON) ) {
 	lat = (int)dlat;
    } else {
 	lat = (int)dlat - 1;
    }
    y = (int)((dlat - lat) * 8);
 }
 void SGBucket::set_bucket(const SGGeod& geod)
 {
    set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
 }
 // Build the path name for this bucket
-string FGBucket::gen_base_path() const {
+string SGBucket::gen_base_path() const {
    // long int index;
    int top_lon, top_lat, main_lon, main_lat;
    char hem, pole;
@@ -78,25 +181,64 @@ string FGBucket::gen_base_path() const {
 	    hem, top_lon, pole, top_lat, 
 	    hem, main_lon, pole, main_lat);
-    FGPath path( raw_path );
+    SGPath path( raw_path );
    return path.str();
 }
 // return width of the tile in degrees
 double SGBucket::get_width() const {
    return sg_bucket_span( get_center_lat() );
 }
 // return height of the tile in degrees
 double SGBucket::get_height() const {
    return SG_BUCKET_SPAN;
 }
 // return width of the tile in meters
 double SGBucket::get_width_m() const {
    double clat = (int)get_center_lat();
    if ( clat > 0 ) {
 	clat = (int)clat + 0.5;
    } else {
 	clat = (int)clat - 0.5;
    }
    double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
    double cos_lat = cos( clat_rad );
    double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
    double local_perimeter = local_radius * SGD_2PI;
    double degree_width = local_perimeter / 360.0;
    return sg_bucket_span( get_center_lat() ) * degree_width;
 }
 // return height of the tile in meters
 double SGBucket::get_height_m() const {
    double perimeter = SG_EQUATORIAL_RADIUS_M * SGD_2PI;
    double degree_height = perimeter / 360.0;
    return SG_BUCKET_SPAN * degree_height;
 }
 // find the bucket which is offset by the specified tile units in the
 // X & Y direction.  We need the current lon and lat to resolve
 // ambiguities when going from a wider tile to a narrower one above or
 // below.  This assumes that we are feeding in
-FGBucket fgBucketOffset( double dlon, double dlat, int dx, int dy ) {
+SGBucket sgBucketOffset( double dlon, double dlat, int dx, int dy ) {
-    FGBucket result( dlon, dlat );
+    SGBucket result( dlon, dlat );
-    double clat = result.get_center_lat() + dy * FG_BUCKET_SPAN;
+    double clat = result.get_center_lat() + dy * SG_BUCKET_SPAN;
    // walk dy units in the lat direction
    result.set_bucket( dlon, clat );
    // find the lon span for the new latitude
-    double span = bucket_span( clat );
+    double span = sg_bucket_span( clat );
    // walk dx units in the lon direction
    double tmp = dlon + dx * span;
@@ -113,7 +255,7 @@ FGBucket fgBucketOffset( double dlon, double dlat, int dx, int dy ) {
 // calculate the offset between two buckets
-void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
+void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
    // Latitude difference
    double c1_lat = b1.get_center_lat();
@@ -121,26 +263,42 @@ void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
    double diff_lat = c2_lat - c1_lat;
 #ifdef HAVE_RINT
-    *dy = (int)rint( diff_lat / FG_BUCKET_SPAN );
+    *dy = (int)rint( diff_lat / SG_BUCKET_SPAN );
 #else
    if ( diff_lat > 0 ) {
-	*dy = (int)( diff_lat / FG_BUCKET_SPAN + 0.5 );
+	*dy = (int)( diff_lat / SG_BUCKET_SPAN + 0.5 );
    } else {
-	*dy = (int)( diff_lat / FG_BUCKET_SPAN - 0.5 );
+	*dy = (int)( diff_lat / SG_BUCKET_SPAN - 0.5 );
    }
 #endif
    // longitude difference
-    double c1_lon = b1.get_center_lon();
+    double diff_lon=0.0;
-    double c2_lon = b2.get_center_lon();
+    double span=0.0;
-    double diff_lon = c2_lon - c1_lon;
+
-    double span;
+    SGBucket tmp_bucket;
-    if ( bucket_span(c1_lat) <= bucket_span(c2_lat) ) {
+    // To handle crossing the bucket size boundary
-	span = bucket_span(c1_lat);
+    //  we need to account for different size buckets.
    if ( sg_bucket_span(c1_lat) <= sg_bucket_span(c2_lat) )
    {
 	span = sg_bucket_span(c1_lat);
    } else {
-	span = bucket_span(c2_lat);
+	span = sg_bucket_span(c2_lat);
    }
    diff_lon = b2.get_center_lon() - b1.get_center_lon();
    if (diff_lon <0.0)
    {
       diff_lon -= b1.get_width()*0.5 + b2.get_width()*0.5 - span;
    } 
    else
    {
       diff_lon += b1.get_width()*0.5 + b2.get_width()*0.5 - span;
    }
 #ifdef HAVE_RINT
    *dx = (int)rint( diff_lon / span );
 #else
@@ -3,128 +3,54 @@
 *
 * Written by Curtis L. Olson, started February 1999.
 *
- * Copyright (C) 1999  Curtis L. Olson - curt@flightgear.org
+ * Copyright (C) 1999  Curtis L. Olson - http://www.flightgear.org/~curt
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 /** \file newbucket.hxx
 * A class and associated utiltity functions to manage world scenery tiling.
 */
 #ifndef _NEWBUCKET_HXX
 #define _NEWBUCKET_HXX
 #include <simgear/compiler.h>
 #include <simgear/constants.h>
 #include <simgear/math/SGMath.hxx>
-#ifdef FG_HAVE_STD_INCLUDES
+#include <cmath>
-#  include <cmath>
+#include <cstdio> // sprintf()
-#  include <cstdio> // sprintf()
+#include <ostream>
-#  include <iostream>
+#include <string>
 #else
 #  include <math.h>
 #  include <stdio.h> // sprintf()
 #  include <iostream.h>
 #endif
-// I don't understand ... <math.h> or <cmath> should be included
+/**
-// already depending on how you defined FG_HAVE_STD_INCLUDES, but I
+ * standard size of a bucket in degrees (1/8 of a degree)
-// can go ahead and add this -- CLO
+ */
-#ifdef __MWERKS__
+#define SG_BUCKET_SPAN      0.125
 #  include <math.h> // needed fabs()
 #endif
-#include STL_STRING
+/**
-
+ * half of a standard SG_BUCKET_SPAN
-FG_USING_STD(string);
+ */
-
+#define SG_HALF_BUCKET_SPAN ( 0.5 * SG_BUCKET_SPAN )
 #if ! defined( FG_HAVE_NATIVE_SGI_COMPILERS )
 FG_USING_STD(ostream);
 #endif
 #define FG_BUCKET_SPAN      0.125   // 1/8 of a degree
 #define FG_HALF_BUCKET_SPAN 0.0625  // 1/2 of 1/8 of a degree = 1/16 = 0.0625
 class FGBucket;
 ostream& operator<< ( ostream&, const FGBucket& );
 bool operator== ( const FGBucket&, const FGBucket& );
 class FGBucket {
 private:
    double cx, cy;  // centerpoint (lon, lat) in degrees of bucket
    int lon;        // longitude index (-180 to 179)
    int lat;        // latitude index (-90 to 89)
    int x;          // x subdivision (0 to 7)
    int y;          // y subdivision (0 to 7)
 public:
    // default constructor
    FGBucket();
    // create a bucket which would contain the specified lon/lat
    FGBucket(const double lon, const double lat);
    // create a bucket based on "long int" index
    FGBucket(const long int bindex);
    // create an impossible bucket if false
    FGBucket(const bool is_good);
    ~FGBucket();
    // Set the bucket params for the specified lat and lon
    void set_bucket( double dlon, double dlat );
    void make_bad ( void );
    // Generate the unique scenery tile index for this bucket
    long int gen_index();
    string gen_index_str() const;
    // Build the path name for this bucket
    string gen_base_path() const;
    // return the center lon of a tile
    double get_center_lon() const;
    // return width of the tile
    double get_width() const;
    // return the center lat of a tile
    double get_center_lat() const;
    // return height of the tile
    double get_height() const;
    // Informational methods
    inline int get_lon() const { return lon; }
    inline int get_lat() const { return lat; }
    inline int get_x() const { return x; }
    inline int get_y() const { return y; }
    // friends
    friend ostream& operator<< ( ostream&, const FGBucket& );
    friend bool operator== ( const FGBucket&, const FGBucket& );
 };
 // return the horizontal tile span factor based on latitude
-inline double bucket_span( double l ) {
+static double sg_bucket_span( double l ) {
    if ( l >= 89.0 ) {
 	return 360.0;
    } else if ( l >= 88.0 ) {
@@ -159,185 +85,262 @@ inline double bucket_span( double l ) {
 }
-// Set the bucket params for the specified lat and lon
+/**
-inline void FGBucket::set_bucket( double dlon, double dlat ) {
+ * A class to manage world scenery tiling.
-    //
+ * This class encapsulates the world tiling scheme.  It provides ways
-    // latitude first
+ * to calculate a unique tile index from a lat/lon, and it can provide
-    //
+ * information such as the dimensions of a given tile.
-    double span = bucket_span( dlat );
+ */
    double diff = dlon - (double)(int)dlon;
-    // cout << "diff = " << diff << "  span = " << span << endl;
+class SGBucket {
-    if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
+private:
-	lon = (int)dlon;
+    short lon;        // longitude index (-180 to 179)
-    } else {
+    short lat;        // latitude index (-90 to 89)
-	lon = (int)dlon - 1;
+    char x;          // x subdivision (0 to 7)
    char y;          // y subdivision (0 to 7)
 public:
    /**
     * Default constructor.
     */
    SGBucket();
    /**
     * Construct a bucket given a specific location.
     * @param dlon longitude specified in degrees
     * @param dlat latitude specified in degrees
     */
    SGBucket(const double dlon, const double dlat);
    /**
     * Construct a bucket given a specific location.
     * @param dlon longitude specified in degrees
     * @param dlat latitude specified in degrees
     */
    SGBucket(const SGGeod& geod);
    /** Construct a bucket.
     *  @param is_good if false, create an invalid bucket.  This is
     *  useful * if you are comparing cur_bucket to last_bucket and
     *  you want to * make sure last_bucket starts out as something
     *  impossible.
     */
    SGBucket(const bool is_good);
    /** Construct a bucket given a unique bucket index number.
     * @param bindex unique bucket index
     */
    SGBucket(const long int bindex);
    /**
     * Reset a bucket to represent a new lat and lon
     * @param dlon longitude specified in degrees
     * @param dlat latitude specified in degrees
     */
    void set_bucket( double dlon, double dlat );
    /**
     * Reset a bucket to represent a new lat and lon
     * @param lonlat an array of double[2] holding lon and lat
     * (specified) in degrees
     */
    void set_bucket( double *lonlat );
    /**
     * Reset a bucket to represent a new lat and lon
     * @param dlon longitude specified in degrees
     * @param dlat latitude specified in degrees
     */
    void set_bucket(const SGGeod& geod);
    /**
     * Create an impossible bucket.
     * This is useful if you are comparing cur_bucket to last_bucket
     * and you want to make sure last_bucket starts out as something
     * impossible.
     */
    inline void make_bad() {
 	set_bucket(0.0, 0.0);
 	lon = -1000;
    }
-    // find subdivision or super lon if needed
+    /**
-    if ( span < FG_EPSILON ) {
+     * Generate the unique scenery tile index for this bucket
-	// polar cap
+     *
-	lon = 0;
+     * The index is constructed as follows:
-	x = 0;
+     * 
-    } else if ( span <= 1.0 ) {
+     * 9 bits - to represent 360 degrees of longitude (-180 to 179)
-	x = (int)((dlon - lon) / span);
+     * 8 bits - to represent 180 degrees of latitude (-90 to 89)
-    } else {
+     *
-	if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
+     * Each 1 degree by 1 degree tile is further broken down into an 8x8
-	    lon = (int)( (int)(lon / span) * span);
+     * grid.  So we also need:
     *
     * 3 bits - to represent x (0 to 7)
     * 3 bits - to represent y (0 to 7)
     * @return tile index
     */
    inline long int gen_index() const {
 	return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
    }
    /**
     * Generate the unique scenery tile index for this bucket in ascii
     * string form.
     * @return tile index in string form
     */
    inline std::string gen_index_str() const {
 	char tmp[20];
 	std::sprintf(tmp, "%ld", 
                     (((long)lon + 180) << 14) + ((lat + 90) << 6)
                     + (y << 3) + x);
 	return (std::string)tmp;
    }
    /**
     * Build the base path name for this bucket.
     * @return base path in string form
     */
    std::string gen_base_path() const;
    /**
     * @return the center lon of a tile.
     */
    inline double get_center_lon() const {
 	double span = sg_bucket_span( lat + y / 8.0 + SG_HALF_BUCKET_SPAN );
 	if ( span >= 1.0 ) {
 	    return lon + span / 2.0;
 	} else {
-	    // cout << " lon = " << lon 
+	    return lon + x * span + span / 2.0;
 	    //  << "  tmp = " << (int)((lon-1) / span) << endl;
 	    lon = (int)( (int)((lon + 1) / span) * span - span);
 	    if ( lon < -180 ) {
 		lon = -180;
 	    }
 	}
 	x = 0;
    }
-    //
+    /**
-    // then latitude
+     * @return the center lat of a tile.
-    //
+     */
-    diff = dlat - (double)(int)dlat;
+    inline double get_center_lat() const {
-
+	return lat + y / 8.0 + SG_HALF_BUCKET_SPAN;
    if ( (dlat >= 0) || (fabs(diff) < FG_EPSILON) ) {
 	lat = (int)dlat;
    } else {
 	lat = (int)dlat - 1;
    }
    y = (int)((dlat - lat) * 8);
 }
    /**
     * @return the width of the tile in degrees.
     */
    double get_width() const;
-// default constructor
+    /**
-inline FGBucket::FGBucket() {}
+     * @return the height of the tile in degrees.
     */
    double get_height() const;
    /**
     * @return the width of the tile in meters.
     */
    double get_width_m() const; 
-// constructor for specified location
+    /**
-inline FGBucket::FGBucket(const double dlon, const double dlat) {
+     * @return the height of the tile in meters.
-    set_bucket(dlon, dlat);
+     */
-}
+    double get_height_m() const;
    /**
     * @return the center of the bucket in geodetic coordinates.
     */
    SGGeod get_center() const
    { return SGGeod::fromDeg(get_center_lon(), get_center_lat()); }
-// create an impossible bucket if false
+    /**
-inline FGBucket::FGBucket(const bool is_good) {
+     * @return the center of the bucket in geodetic coordinates.
-    set_bucket(0.0, 0.0);
+     */
-    if ( !is_good ) {
+    SGGeod get_corner(unsigned num) const
-	lon = -1000;
+    {
        double lonFac = ((num + 1) & 2) ? 0.5 : -0.5;
        double latFac = ((num    ) & 2) ? 0.5 : -0.5;
        return SGGeod::fromDeg(get_center_lon() + lonFac*get_width(),
                               get_center_lat() + latFac*get_height());
    }
 }
    // Informational methods.
-// Parse a unique scenery tile index and find the lon, lat, x, and y
+    /**
-inline FGBucket::FGBucket(const long int bindex) {
+     * @return the lon of the lower left corner of 
-    long int index = bindex;
+     * the 1x1 chunk containing this tile.
     */
    inline int get_chunk_lon() const { return lon; }
-    lon = index >> 14;
+    /**
-    index -= lon << 14;
+     * @return the lat of the lower left corner of 
-    lon -= 180;
+     * the 1x1 chunk containing this tile.
     */
    inline int get_chunk_lat() const { return lat; }
-    lat = index >> 6;
+    /**
-    index -= lat << 6;
+     * @return the x coord within the 1x1 degree chunk this tile.
-    lat -= 90;
+     */
    inline int get_x() const { return x; }
-    y = index >> 3;
+    /**
-    index -= y << 3;
+     * @return the y coord within the 1x1 degree chunk this tile.
     */
    inline int get_y() const { return y; }
-    x = index;
+    // friends
 }
    friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
    friend bool operator== ( const SGBucket&, const SGBucket& );
 };
-// default destructor
+inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
-inline FGBucket::~FGBucket() {}
+    {
-
+        return !(lhs == rhs);
 // Generate the unique scenery tile index for this bucket
 // 
 // The index is constructed as follows:
 // 
 // 9 bits - to represent 360 degrees of longitude (-180 to 179)
 // 8 bits - to represent 180 degrees of latitude (-90 to 89)
 //
 // Each 1 degree by 1 degree tile is further broken down into an 8x8
 // grid.  So we also need:
 //
 // 3 bits - to represent x (0 to 7)
 // 3 bits - to represent y (0 to 7)
 inline long int FGBucket::gen_index() {
    return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
 }
 inline string FGBucket::gen_index_str() const {
    char tmp[20];
    sprintf(tmp, "%ld", 
 	    (((long)lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x);
    return (string)tmp;
 }
 // return the center lon of a tile
 inline double FGBucket::get_center_lon() const {
    double span = bucket_span( lat + y / 8.0 + FG_HALF_BUCKET_SPAN );
    if ( span >= 1.0 ) {
 	return lon + span / 2.0;
    } else {
 	return lon + x * span + span / 2.0;
    }
 }
-// return the center lat of a tile
+/**
-inline double FGBucket::get_center_lat() const {
+ * \relates SGBucket
-    return lat + y / 8.0 + FG_HALF_BUCKET_SPAN;
+ * Return the bucket which is offset from the specified dlon, dlat by
-}
+ * the specified tile units in the X & Y direction.
 * @param dlon starting lon in degrees
 * @param dlat starting lat in degrees
 * @param x number of bucket units to offset in x (lon) direction
 * @param y number of bucket units to offset in y (lat) direction
 * @return offset bucket
 */
 SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
-// return width of the tile
+/**
-inline double FGBucket::get_width() const {
+ * \relates SGBucket
-    return bucket_span( get_center_lat() );
+ * Calculate the offset between two buckets (in quantity of buckets).
-}
+ * @param b1 bucket 1
 * @param b2 bucket 2
 * @param dx offset distance (lon) in tile units
 * @param dy offset distance (lat) in tile units
 */
 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy );
-// return height of the tile
+/**
-inline double FGBucket::get_height() const {
+ * Write the bucket lon, lat, x, and y to the output stream.
-    return FG_BUCKET_SPAN;
+ * @param out output stream
-}
+ * @param b bucket
-
+ */
-
+inline std::ostream&
-// create an impossible bucket
+operator<< ( std::ostream& out, const SGBucket& b )
 inline void FGBucket::make_bad( void ) {
    set_bucket(0.0, 0.0);
 	lon = -1000;
 }
 // offset a bucket struct by the specified tile units in the X & Y
 // direction
 FGBucket fgBucketOffset( double dlon, double dlat, int x, int y );
 // calculate the offset between two buckets
 void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy );
 /*
 // Given a lat/lon, fill in the local tile index array
 void fgBucketGenIdxArray(fgBUCKET *p1, fgBUCKET *tiles, int width, int height);
 */
 inline ostream&
 operator<< ( ostream& out, const FGBucket& b )
 {
    return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
 }
 /**
 * Compare two bucket structures for equality.
 * @param b1 bucket 1
 * @param b2 bucket 2
 * @return comparison result
 */
 inline bool
-operator== ( const FGBucket& b1, const FGBucket& b2 )
+operator== ( const SGBucket& b1, const SGBucket& b2 )
 {
    return ( b1.lon == b2.lon &&
 	     b1.lat == b2.lat &&
@@ -0,0 +1,2 @@
 Makefile
 Makefile.in
@@ -0,0 +1,2 @@
 Makefile
 Makefile.in
@@ -0,0 +1,14 @@
 includedir = @includedir@/compatibility/
 include_HEADERS	= \
 	iostream \
 	strstream \
 	sstream \
 	istream \
 	fstream \
 	iterator \
 	iomanip \
 	new \
 	streambuf \
 	\
 	irix_string
@@ -0,0 +1,19 @@
 #ifndef __SG_FSTREAM
 #define __SG_FSTREAM 1
 # if defined(sgi) && !defined(__GNUC__)
 # include <fstream.h>
  namespace std {
    using ::fstream;
    using ::ofstream;
    using ::ifstream;
  };
 # endif
 #endif // !__SG_FSTREAM
@@ -0,0 +1,16 @@
 #ifndef __SG_IOMANIP
 #define __SG_IOMANIP 1
 # include <iomanip.h>
 namespace std {
   using ::setw;
   using ::setprecision;
   inline int  setfill(int f) { ::setfill(f); }
 };
 #endif // !__SG_IOMANIP
@@ -0,0 +1,52 @@
 #ifndef __SG_IOSTREAM
 #define __SG_IOSTREAM 1
 # if defined(sgi) && !defined(__GNUC__)
 # include <fstream>
 # include <iostream.h>
  class ios_base : public ios {
  public:
    typedef int  openmode;
    typedef int  seekdir;
    enum { binary = 0 };
  };
  namespace std {
    using ::cin;
    using ::cout;
    using ::cerr;
    using ::clog;
    using ::endl;
    using ::ios;
    using ::ios_base;
    using ::iostream;
    using ::istream;
    using ::ostream;
    using ::dec;
    using ::oct;
    using ::hex;
    enum  { skipws=ios::skipws,
            left=ios::left, right=ios::right, internal=ios::internal,
            showbase=ios::showbase, showpoint=ios::showpoint,
            uppercase=ios::uppercase, showpos=ios::showpos,
            scientific=ios::scientific, fixed=ios::fixed,
            unitbuf=ios::unitbuf, stdio=ios::stdio
 #if _BOOL && __EDG_ABI_COMPATIBILITY_VERSION>227 /* bool support */
            ,boolalpha=ios::boolalpha
 #endif /* bool support */
          };
  };
 # endif
 #endif // !__SG_IOSTREAM
@@ -0,0 +1,47 @@
 #ifndef __SGI_HXX
 #define __SGI_HXX 1
 #ifdef __cplusplus
 #include <string>
 inline bool
 operator!=( const std::string& lhs, const char* rhs)
 {
    return lhs.compare( rhs ) != 0;
 }
 inline bool
 operator!=( const char* lhs, const std::string& rhs)
 {
    return rhs.compare( lhs ) != 0;
 }
 inline bool
 operator==( const std::string& lhs, const char* rhs)
 {
    return lhs.compare( rhs ) == 0;
 }
 inline bool
 operator==( const char* lhs, const std::string& rhs)
 {
    return rhs.compare( lhs ) == 0;
 }
 inline std::string
 operator+(const std::string& lhs, const char* rhs)
 {
    return lhs + std::string(rhs);
 }
 inline std::string
 operator+(const char* lhs, const std::string& rhs)
 {
    return std::string(lhs) + rhs;
 }
 #endif /* __cplusplus */
 #endif /* !__SGI_HXX */
@@ -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
@@ -0,0 +1,8 @@
 #ifndef __SG_ITERATOR
 #define __SG_ITERATOR 1
 # include <iterator.h>
 #endif // !__SG_ITERATOR
@@ -0,0 +1,12 @@
 #ifndef __SG_NEW
 #define __SG_NEW 1
 #if defined(sgi) && !defined(__GNUC__)
 # include <new.h>
 #endif
 #endif // !__SG_NEW
@@ -0,0 +1,22 @@
 #ifndef __SG_SSTREAM
 #define __SG_SSTREAM 1
 # include <iostream>
 # include <strstream>
 # include <string>
 namespace std {
   class ostringstream : public ostrstream {
   public:
      std::string str() {  return string(ostrstream::str()); }
   };
   typedef istrstream istringstream;
 };
 #endif // !__SG_SSTREAM
@@ -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
@@ -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
@@ -0,0 +1,2 @@
 Makefile
 Makefile.in
@@ -0,0 +1,22 @@
 includedir = @includedir@/compatibility
 EXTRA_DIST = README
 include_HEADERS	= \
 	cfloat \
 	csetjmp \
 	cstdio \
 	cwchar \
 	cassert \
 	climits \
 	csignal \
 	cstdlib \
 	cwctype \
 	cctype \
 	clocale \
 	cstdarg \
 	cstring \
 	cerrno \
 	cmath \
 	cstddef \
 	ctime
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -0,0 +1,3 @@
 SUBDIRS = $(MIPSpro_DIRS)
 DIST_SUBDIRS = MIPSpro721 MIPSpro740
@@ -1,216 +1,107 @@
 /**************************************************************************
 * compiler.h -- C++ Compiler Portability Macros
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 *
 **************************************************************************/
-#ifndef _COMPILER_H
+/** \file compiler.h
-#define _COMPILER_H
+ * A set of defines to encapsulate compiler and platform differences.
 * Please refer to the source code for full documentation on this file.
 *
 * This file is useful to set compiler-specific options in every file - for
 * example, disabling warnings.
 *
 */
-// What this file does.
+#ifndef _SG_COMPILER_H
-//  (1)  Defines macros for some STL includes which may be affected
+#define _SG_COMPILER_H
-//       by file name length limitations.
+
-//  (2)  Defines macros for some features not supported by all C++ compilers.
+/*
-//  (3)  Defines 'explicit' as a null macro if the compiler doesn't support
+ * Helper macro SG_STRINGIZE:
-//       the explicit keyword.
+ * Converts the parameter X to a string after macro replacement
-//  (4)  Defines 'typename' as a null macro if the compiler doesn't support
+ * on X has been performed.
-//       the typename keyword.
+ */
-//  (5)  Defines bool, true and false if the compiler doesn't do so.
+#define SG_STRINGIZE(X) SG_DO_STRINGIZE(X)
-//  (6)  Defines FG_EXPLICIT_FUNCTION_TMPL_ARGS if the compiler
+#define SG_DO_STRINGIZE(X) #X
 //       supports calling a function template by providing its template
 //       arguments explicitly.
 //  (7)  Defines FG_NEED_AUTO_PTR if STL doesn't provide auto_ptr<>.
 //  (8)  Defines FG_NO_ARROW_OPERATOR if the compiler is unable
 //       to support operator->() for iterators.
 //  (9)  Defines FG_USE_EXCEPTIONS if the compiler supports exceptions.
 //       Note: no FlightGear code uses exceptions.
 //  (10) Define FG_NAMESPACES if the compiler supports namespaces.
 //  (11) FG_MATH_FN_IN_NAMESPACE_STD -- not used??
 //  (12) Define FG_HAVE_STD if std namespace is supported.
 //  (13) Defines FG_CLASS_PARTIAL_SPECIALIZATION if the compiler 
 //       supports partial specialization of class templates.
 //  (14) Defines FG_HAVE_STD_INCLUDES to use ISO C++ Standard headers.
 //  (15) Defines FG_HAVE_STREAMBUF if <streambuf> of <streambuf.h> are present.
 //  (16) Define FG_MATH_EXCEPTION_CLASH if math.h defines an exception class
 //       that clashes with the one defined in <stdexcept>.
 #ifdef __GNUC__
-#  if __GNUC__ == 2 
+#  if __GNUC__ < 3
-#    if __GNUC_MINOR__ < 8
+#    error Time to upgrade. GNU compilers < 3.0 not supported
-
+#  elif (__GNUC__ == 3) && (__GNUC_MINOR__ < 4)
-       // g++-2.7.x
+#    warning GCC compilers prior to 3.4 are suspect  
 #      define STL_ALGORITHM  <algorithm>
 #      define STL_FUNCTIONAL <functional>
 #      define STL_IOMANIP    <iomanip.h>
 #      define STL_IOSTREAM   <iostream.h>
 #      define STL_FSTREAM    <fstream.h>
 #      define STL_STDEXCEPT  <stdexcept>
 #      define STL_STRING     <string>
 #      define STL_STRSTREAM  <strstream.h>
 #      define FG_NEED_AUTO_PTR
 #      define FG_NO_DEFAULT_TEMPLATE_ARGS
 #      define FG_INCOMPLETE_FUNCTIONAL
 #      define FG_NO_ARROW_OPERATOR
 #    elif __GNUC_MINOR__ >= 8
       // g++-2.8.x and egcs-1.x
 #      define FG_EXPLICIT_FUNCTION_TMPL_ARGS
 #      define FG_NEED_AUTO_PTR
 #      define FG_MEMBER_TEMPLATES
 #      define FG_NAMESPACES
 #      define FG_HAVE_STD
 #      define FG_HAVE_STREAMBUF
 #      define FG_CLASS_PARTIAL_SPECIALIZATION
 #      define STL_ALGORITHM  <algorithm>
 #      define STL_FUNCTIONAL <functional>
 #      define STL_IOMANIP    <iomanip>
 #      define STL_IOSTREAM   <iostream>
 #      define STL_FSTREAM    <fstream>
 #      define STL_STDEXCEPT  <stdexcept>
 #      define STL_STRING     <string>
 #      define STL_STRSTREAM  <strstream>
 #    endif
 #  else
 #    error Time to upgrade. GNU compilers < 2.7 not supported
 #  endif
 #endif
-//
+#  define SG_COMPILER_STR "GNU C++ version " SG_STRINGIZE(__GNUC__) "." SG_STRINGIZE(__GNUC_MINOR__)
-// Metrowerks 
+#endif // __GNUC__
 //
 #if defined(__MWERKS__)
 /*
  CodeWarrior compiler from Metrowerks, Inc.
 */
 #  define FG_HAVE_TRAITS
 #  define FG_HAVE_STD_INCLUDES
 #  define FG_HAVE_STD
 #  define FG_NAMESPACES
-#  define STL_ALGORITHM  <algorithm>
+/* KAI C++ */
-#  define STL_FUNCTIONAL <functional>
+#if defined(__KCC)
-#  define STL_IOMANIP    <iomanip>
+#  define SG_COMPILER_STR "Kai C++ version " SG_STRINGIZE(__KCC_VERSION)
-#  define STL_IOSTREAM   <iostream>
+#endif // __KCC
 #  define STL_FSTREAM    <fstream>
 #  define STL_STDEXCEPT  <stdexcept>
 #  define STL_STRING     <string>
 // Temp:
 #  define bcopy(from, to, n) memcpy(to, from, n)
 // -rp- please use FG_MEM_COPY everywhere !
 #  define FG_MEM_COPY(to,from,n) memcpy(to, from, n)
 // -dw- currently used glut has no game mode stuff
 #  define GLUT_WRONG_VERSION
 #endif
 //
 // Microsoft compilers.
 //
 #ifdef _MSC_VER
-#  if _MSC_VER == 1200 // msvc++ 6.0
+#  define bcopy(from, to, n) memcpy(to, from, n)
 #    define FG_NAMESPACES
 #    define FG_HAVE_STD
 #    define FG_HAVE_STD_INCLUDES
 #    define FG_HAVE_STREAMBUF
-#    define STL_ALGORITHM  <algorithm>
+#  if _MSC_VER >= 1200  // msvc++ 6.0 or greater
-#    define STL_FUNCTIONAL <functional>
+#    define isnan _isnan
-#    define STL_IOMANIP    <iomanip>
+#    define snprintf _snprintf
-#    define STL_IOSTREAM   <iostream>
+#    define copysign _copysign
 #    define STL_FSTREAM    <fstream>
 #    define STL_STDEXCEPT  <stdexcept>
 #    define STL_STRING     <string>
 #    define STL_STRSTREAM  <strstream>
 #    pragma warning(disable: 4786) // identifier was truncated to '255' characters
 #    pragma warning(disable: 4244) // conversion from double to float
 #    pragma warning(disable: 4305) //
 #  elif _MSC_VER == 1100 // msvc++ 5.0
 #    error MSVC++ 5.0 still to be supported...
 #  else
 #    error What version of MSVC++ is this?
 #  endif
 #endif
-#ifdef __BORLANDC__
+#    define SG_COMPILER_STR "Microsoft Visual C++ version " SG_STRINGIZE(_MSC_VER)
 # if defined(HAVE_SGI_STL_PORT)
-// Use quotes around long file names to get around Borland's include hackery
+#endif // _MSC_VER
 #  define STL_ALGORITHM  "algorithm"
 #  define STL_FUNCTIONAL "functional"
 #  define FG_MATH_EXCEPTION_CLASH
 # else
 #  define STL_ALGORITHM  <algorithm>
 #  define STL_FUNCTIONAL <functional>
 #  define STL_IOMANIP    <iomanip>
 #  define STL_STDEXCEPT  <stdexcept>
 #  define STL_STRSTREAM  <strstream>
 #  define FG_INCOMPLETE_FUNCTIONAL
 # endif // HAVE_SGI_STL_PORT
 #  define STL_IOSTREAM   <iostream>
 #  define STL_FSTREAM    <fstream>
 #  define STL_STRING     <string>
 #  define FG_NO_DEFAULT_TEMPLATE_ARGS
 #  define FG_NAMESPACES
 // #  define FG_HAVE_STD
 #endif // __BORLANDC__
 //
 // Native SGI compilers
 //
 #if defined ( sgi ) && !defined( __GNUC__ )
-#  define FG_HAVE_NATIVE_SGI_COMPILERS
+# if (_COMPILER_VERSION < 740)
 #  error Need MipsPro 7.4.0 or higher now
 # endif
-#  define FG_EXPLICIT_FUNCTION_TMPL_ARGS
+#define SG_HAVE_NATIVE_SGI_COMPILERS
 #  define FG_NEED_AUTO_PTR
 #  define FG_MEMBER_TEMPLATES
 #  define FG_NAMESPACES
 #  define FG_HAVE_STD
 #  define FG_CLASS_PARTIAL_SPECIALIZATION
-#  define STL_ALGORITHM  <algorithm>
+#pragma set woff 1001,1012,1014,1116,1155,1172,1174
-#  define STL_FUNCTIONAL <functional>
+#pragma set woff 1401,1460,1551,1552,1681
-#  define STL_IOMANIP    <iomanip.h>
+
-#  define STL_IOSTREAM   <iostream.h>
+#ifdef __cplusplus
-#  define STL_FSTREAM    <fstream.h>
+# pragma set woff 1682,3303
-#  define STL_STDEXCEPT  <stdexcept>
+# pragma set woff 3624
-#  define STL_STRING     <string>
+#endif
-#  define STL_STRSTREAM  <strstream>
+
 #  define SG_COMPILER_STR "SGI MipsPro compiler version " SG_STRINGIZE(_COMPILER_VERSION)
 #endif // Native SGI compilers
-#if defined ( sun )
+#if defined (__sun)
 #  include <strings.h>
 #  include <memory.h>
 #  if defined ( __cplusplus )
@@ -221,83 +112,60 @@
 #  else
     extern void *memmove(void *, const void *, size_t);
 #  endif // __cplusplus
 #  if  !defined( __GNUC__ )
 #   define SG_COMPILER_STR "Sun compiler version " SG_STRINGIZE(__SUNPRO_CC)
 #  endif
 #endif // sun
 //
 // Intel C++ Compiler
 //
 #if defined(__ICC) || defined (__ECC)
 #  define SG_COMPILER_STR "Intel C++ version " SG_STRINGIZE(__ICC)
 #endif // __ICC
 //
 // Platform dependent gl.h and glut.h definitions
 //
 #ifdef __APPLE__
 #  ifdef __GNUC__
 #    if ( __GNUC__ > 3 ) || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 3 )
 inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
 #    else
    // any C++ header file undefines isinf and isnan
    // so this should be included before <iostream>
    // the functions are STILL in libm (libSystem on mac os x)
 extern "C" int (isnan)(double);
 extern "C" int (isinf)(double);
 #    endif
 #  else
 inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
 #  endif
 #endif
 #if defined (__FreeBSD__)
 #  if __FreeBSD_version < 500000
     extern "C" {
       inline int isnan(double r) { return !(r <= 0 || r >= 0); }
     }
 #  endif
 #endif
 #if defined (__CYGWIN__)
 #  include <ieeefp.h>		// isnan
 #endif
 #if defined(__MINGW32__)
 #  define isnan(x) _isnan(x)
 #endif
 //
 // No user modifiable definitions beyond here.
 //
-#ifdef FG_NEED_EXPLICIT
+#endif // _SG_COMPILER_H
 #  define explicit
 #endif
 #ifdef FG_NEED_TYPENAME
 #  define typename
 #endif
 #ifdef FG_NEED_MUTABLE
 #  define mutable
 #endif
 #ifdef FG_NEED_BOOL
   typedef int bool;
 #  define true 1
 #  define false 0
 #endif
 #ifdef FG_EXPLICIT_FUNCTION_TMPL_ARGS
 #  define FG_NULL_TMPL_ARGS <>
 #else
 #  define FG_NULL_TMPL_ARGS
 #endif
 #ifdef FG_CLASS_PARTIAL_SPECIALIZATION
 # define FG_TEMPLATE_NULL template<>
 #else
 # define FG_TEMPLATE_NULL
 #endif
 // FG_NO_NAMESPACES is a hook so that users can disable namespaces
 // without having to edit library headers.
 #if defined(FG_NAMESPACES) && !defined(FG_NO_NAMESPACES)
 #   define FG_NAMESPACE(X) namespace X {
 #   define FG_NAMESPACE_END }
 #   define FG_USING_NAMESPACE(X) using namespace X
 # else
 #   define FG_NAMESPACE(X)
 #   define FG_NAMESPACE_END
 #   define FG_USING_NAMESPACE(X)
 #endif
 # ifdef FG_HAVE_STD
 #  define FG_USING_STD(X) using std::X
 #  define STD std
 # else
 #  define FG_USING_STD(X) 
 #  define STD
 # endif
 // Additional <functional> implementation from SGI STL 3.11
 // Adapter function objects: pointers to member functions
 #ifdef FG_INCOMPLETE_FUNCTIONAL
 template <class _Ret, class _Tp>
 class const_mem_fun_ref_t
 #ifndef __BORLANDC__
    : public unary_function<_Tp,_Ret>
 #endif // __BORLANDC__
 {
 public:
  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
 private:
  _Ret (_Tp::*_M_f)() const;
 };
 template <class _Ret, class _Tp>
 inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
  { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
 #endif // FG_INCOMPLETE_FUNCTIONAL
 #endif // _COMPILER_H
@@ -2,142 +2,162 @@
 //
 // Written by Curtis Olson, started February 2000.
 //
-// Copyright (C) 2000  Curtis L. Olson  - curt@flightgear.org
+// Copyright (C) 2000  Curtis L. Olson - http://www.flightgear.org/~curt/
 //
-// This program is free software; you can redistribute it and/or
+// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
+// modify it under the terms of the GNU Library General Public
-// published by the Free Software Foundation; either version 2 of the
+// License as published by the Free Software Foundation; either
-// License, or (at your option) any later version.
+// 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
+// This library is distributed in the hope that it will be useful,
-// WITHOUT ANY WARRANTY; without even the implied warranty of
+// 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.
+// Library 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.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
-
+/** \file constants.h
-#ifndef _SUPPORTGEAR_CONSTANTS_H
+ * Various constant definitions.
-#define _SUPPORTGEAR_CONSTANTS_H
+ */
-#ifdef HAVE_CONFIG_H
+#ifndef _SG_CONSTANTS_H
-#  include <config.h>
+#define _SG_CONSTANTS_H
-#endif
+
 #include <simgear/compiler.h>
-#ifdef FG_HAVE_STD_INCLUDES
+#include <cmath>
-#  include <cmath>
+
-#else
+
-#  ifdef FG_MATH_EXCEPTION_CLASH
+#include <plib/sg.h>
 #    define exception C_exception
 #  endif
 #  include <math.h>
 #endif
 // Make sure PI is defined in its various forms
-// PI, only PI, and nothing but PI
+// SG_PI and SGD_PI (float and double) come from plib/sg.h
 #ifdef M_PI
 #  define  FG_PI    M_PI
 #else
 #  define  FG_PI    3.14159265358979323846
 #endif
-// 2 * PI
+/** 2 * PI */
-#define FG_2PI      6.28318530717958647692
+#define SGD_2PI      6.28318530717958647692
-// PI / 2
+/** PI / 2 */
 #ifdef M_PI_2
-#  define  FG_PI_2  M_PI_2
+#  define  SGD_PI_2  M_PI_2
 #else
-#  define  FG_PI_2  1.57079632679489661923
+#  define  SGD_PI_2  1.57079632679489661923
 #endif
-// PI / 4
+/** PI / 4 */
-#define FG_PI_4     0.78539816339744830961
+#define SGD_PI_4     0.78539816339744830961
-#ifndef M_E
+/** \def SG_E "e" */
-#  define M_E     2.7182818284590452354
+#ifdef M_E
 #  define SG_E     M_E
 #else
 #  define SG_E     2.7182818284590452354
 #endif
-// ONE_SECOND is pi/180/60/60, or about 100 feet at earths' equator
+/** pi/180/60/60, or about 100 feet at earths' equator */
-#define ONE_SECOND 4.848136811E-6
+#define SG_ONE_SECOND 4.848136811E-6
-// Radius of Earth in kilometers at the equator.  Another source had
+/** Radius of Earth in kilometers at the equator.  Another source had
-// 6378.165 but this is probably close enough
+ *  6378.165 but this is probably close enough */
-#define EARTH_RAD 6378.155
+#define SG_EARTH_RAD 6378.155
 // Maximum terrain elevation from sea level
 #define SG_MAX_ELEVATION_M 9000.0
 // Earth parameters for WGS 84, taken from LaRCsim/ls_constants.h
-// Value of earth radius from [8]
+/** Value of earth radius from LaRCsim (ft) */
-#define EQUATORIAL_RADIUS_FT 20925650.    // ft
+#define SG_EQUATORIAL_RADIUS_FT  20925650.
 #define EQUATORIAL_RADIUS_M   6378138.12  // meter
 // Radius squared
 #define RESQ_FT 437882827922500.          // ft
 #define RESQ_M   40680645877797.1344      // meter
-// Value of earth flattening parameter from ref [8] 
+/** Value of earth radius from LaRCsim (meter) */
-//
+#define SG_EQUATORIAL_RADIUS_M   6378138.12
 //      Note: FP = f
 //            E  = 1-f
 //            EPS = sqrt(1-(1-f)^2)
 //
-#define FP    0.003352813178
+/** Radius squared (ft) */
-#define E     0.996647186
+#define SG_EQ_RAD_SQUARE_FT 437882827922500.
 #define EPS   0.081819221
 #define INVG  0.031080997
 // Time Related Parameters
 #define MJD0  2415020.0
 #define J2000 (2451545.0 - MJD0)
 #define SIDRATE         .9972695677
 /** Radius squared (meter) */
 #define SG_EQ_RAD_SQUARE_M   40680645877797.1344
 // Conversions
-// Degrees to Radians
+/** Arc seconds to radians.  (arcsec*pi)/(3600*180) = rad */
-#define DEG_TO_RAD       0.017453292          // deg*pi/180 = rad
+#define SG_ARCSEC_TO_RAD    4.84813681109535993589e-06 
-// Radians to Degrees
+/** Radians to arc seconds.  (rad*3600*180)/pi = arcsec */
-#define RAD_TO_DEG       57.29577951          // rad*180/pi = deg
+#define SG_RAD_TO_ARCSEC    206264.806247096355156
-// Arc seconds to radians                     // (arcsec*pi)/(3600*180) = rad
+/** Feet to Meters */
-#define ARCSEC_TO_RAD    4.84813681109535993589e-06 
+#define SG_FEET_TO_METER    0.3048
-// Radians to arc seconds                     // (rad*3600*180)/pi = arcsec
+/** Meters to Feet */
-#define RAD_TO_ARCSEC    206264.806247096355156
+#define SG_METER_TO_FEET    3.28083989501312335958  
-// Feet to Meters
+/** Meters to Nautical Miles.  1 nm = 6076.11549 feet */
-#define FEET_TO_METER    0.3048
+#define SG_METER_TO_NM      0.0005399568034557235
-// Meters to Feet
+/** Nautical Miles to Meters */
-#define METER_TO_FEET    3.28083989501312335958  
+#define SG_NM_TO_METER      1852.0000
-// Meters to Nautical Miles, 1 nm = 6076.11549 feet
+/** Meters to Statute Miles. */
-#define METER_TO_NM      0.00053995680
+#define SG_METER_TO_SM      0.0006213699494949496
-// Nautical Miles to Meters
+/** Statute Miles to Meters. */
-#define NM_TO_METER      1852.0000
+#define SG_SM_TO_METER      1609.3412196
-// Radians to Nautical Miles, 1 nm = 1/60 of a degree
+/** Radians to Nautical Miles.  1 nm = 1/60 of a degree */
-#define NM_TO_RAD        0.00029088820866572159
+#define SG_NM_TO_RAD        0.00029088820866572159
-// Nautical Miles to Radians
+/** Nautical Miles to Radians */
-#define RAD_TO_NM        3437.7467707849392526
+#define SG_RAD_TO_NM        3437.7467707849392526
-// For divide by zero avoidance, this will be close enough to zero
+/** meters per second to Knots */
-#define FG_EPSILON 0.0000001
+#define SG_MPS_TO_KT        1.9438444924406046432
 /** Knots to meters per second */
 #define SG_KT_TO_MPS        0.5144444444444444444
 /** Feet per second to Knots */
 #define SG_FPS_TO_KT        0.5924838012958962841
 /** Knots to Feet per second */
 #define SG_KT_TO_FPS        1.6878098571011956874
 /** meters per second to Miles per hour */
 #define SG_MPS_TO_MPH       2.2369362920544020312
 /** meetrs per hour to Miles per second */
 #define SG_MPH_TO_MPS       0.44704
 /** Meters per second to Kilometers per hour */
 #define SG_MPS_TO_KMH       3.6
 /** Kilometers per hour to meters per second */
 #define SG_KMH_TO_MPS       0.2777777777777777778
 /** Pascal to Inch Mercury */
 #define SG_PA_TO_INHG       0.0002952998330101010
 /** Inch Mercury to Pascal */
 #define SG_INHG_TO_PA       3386.388640341
-#endif // _SUPPORTGEAR_CONSTANTS_H
+/** For divide by zero avoidance, this will be close enough to zero */
 #define SG_EPSILON 0.0000001
 /** Highest binobj format version we know how to read/write.  This starts at
 *  0 and can go up to 65535 */
 #define SG_BINOBJ_VERSION 6
 /** for backwards compatibility */
 #define SG_SCENERY_FILE_FORMAT "0.4"
 #endif // _SG_CONSTANTS_H
@@ -0,0 +1,3 @@
 .deps
 Makefile
 Makefile.in
@@ -8,4 +8,4 @@ include_HEADERS = debug_types.h logstream.hxx
 libsgdebug_a_SOURCES = logstream.cxx
-INCLUDES += -I$(top_builddir)
+INCLUDES = -I$(top_srcdir)
@@ -1,38 +1,48 @@
-// NB: To add a dbg_class, add it here, and add it to the structure in
+/** \file debug_types.h
-// fg_debug.c
+ *  Define the various logging classes and prioritiess
 */
 /** 
 * Define the possible classes/categories of logging messages
 */
 typedef enum {
-    FG_NONE      = 0x00000000,
+    SG_NONE      = 0x00000000,
-    FG_TERRAIN   = 0x00000001,
+    SG_TERRAIN   = 0x00000001,
-    FG_ASTRO     = 0x00000002,
+    SG_ASTRO     = 0x00000002,
-    FG_FLIGHT    = 0x00000004,
+    SG_FLIGHT    = 0x00000004,
-    FG_INPUT     = 0x00000008,
+    SG_INPUT     = 0x00000008,
-    FG_GL        = 0x00000010,
+    SG_GL        = 0x00000010,
-    FG_VIEW      = 0x00000020,
+    SG_VIEW      = 0x00000020,
-    FG_COCKPIT   = 0x00000040,
+    SG_COCKPIT   = 0x00000040,
-    FG_GENERAL   = 0x00000080,
+    SG_GENERAL   = 0x00000080,
-    FG_MATH      = 0x00000100,
+    SG_MATH      = 0x00000100,
-    FG_EVENT     = 0x00000200,
+    SG_EVENT     = 0x00000200,
-    FG_AIRCRAFT  = 0x00000400,
+    SG_AIRCRAFT  = 0x00000400,
-    FG_AUTOPILOT = 0x00000800,
+    SG_AUTOPILOT = 0x00000800,
-    FG_IO        = 0x00001000,
+    SG_IO        = 0x00001000,
-    FG_CLIPPER   = 0x00002000,
+    SG_CLIPPER   = 0x00002000,
-    FG_NETWORK   = 0x00004000,
+    SG_NETWORK   = 0x00004000,
-    FG_UNDEFD    = 0x00008000, // For range checking
+    SG_ATC       = 0x00008000,
    SG_NASAL     = 0x00010000,
    SG_INSTR     = 0x00020000,
    SG_SYSTEMS   = 0x00040000,
    SG_UNDEFD    = 0x00080000, // For range checking
-    FG_ALL     = 0xFFFFFFFF
+    SG_ALL     = 0xFFFFFFFF
-} fgDebugClass;
+} sgDebugClass;
-// NB: To add a priority, add it here.
+/**
 * Define the possible logging priorities (and their order).
 */
 typedef enum {
-    FG_BULK,	    // For frequent messages
+    SG_BULK = 1,       // For frequent messages
-    FG_DEBUG, 	    // Less frequent debug type messages
+    SG_DEBUG,          // Less frequent debug type messages
-    FG_INFO,        // Informatory messages
+    SG_INFO,           // Informatory messages
-    FG_WARN,	    // Possible impending problem
+    SG_WARN,           // Possible impending problem
-    FG_ALERT       // Very possible impending problem
+    SG_ALERT           // Very possible impending problem
-    // FG_EXIT,        // Problem (no core)
+    // SG_EXIT,        // Problem (no core)
-    // FG_ABORT        // Abandon ship (core)
+    // SG_ABORT        // Abandon ship (core)
-} fgDebugPriority;
+} sgDebugPriority;
@@ -4,29 +4,47 @@
 //
 // Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
 //
-// This program is free software; you can redistribute it and/or
+// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
+// modify it under the terms of the GNU Library General Public
-// published by the Free Software Foundation; either version 2 of the
+// License as published by the Free Software Foundation; either
-// License, or (at your option) any later version.
+// 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
+// This library is distributed in the hope that it will be useful,
-// WITHOUT ANY WARRANTY; without even the implied warranty of
+// 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.
+// Library 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.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
 #include <iostream>
 #include "logstream.hxx"
 logstream *logstream::global_logstream = 0;
 bool            logbuf::logging_enabled = true;
-fgDebugClass    logbuf::logClass        = FG_NONE;
+#ifdef _MSC_VER
-fgDebugPriority logbuf::logPriority     = FG_INFO;
+   bool         logbuf::has_console = true;
 #endif
 sgDebugClass    logbuf::logClass        = SG_NONE;
 sgDebugPriority logbuf::logPriority     = SG_INFO;
 streambuf*      logbuf::sbuf            = NULL;
 namespace {
 struct ignore_me
 {
    ignore_me()
    {
        logstream::initGlobalLogstream();
    }
 };
 static ignore_me im;
 }
 logbuf::logbuf()
 {
 //     if ( sbuf == NULL )
@@ -49,15 +67,48 @@ logbuf::set_sb( streambuf* sb )
 }
 void
-logbuf::set_log_level( fgDebugClass c, fgDebugPriority p )
+logbuf::set_log_level( sgDebugClass c, sgDebugPriority p )
 {
    logClass = c;
    logPriority = p;
 }
 void
-logstream::setLogLevels( fgDebugClass c, fgDebugPriority p )
+logbuf::set_log_classes (sgDebugClass c)
 {
    logClass = c;
 }
 sgDebugClass
 logbuf::get_log_classes ()
 {
    return logClass;
 }
 void
 logbuf::set_log_priority (sgDebugPriority p)
 {
    logPriority = p;
 }
 sgDebugPriority
 logbuf::get_log_priority ()
 {
    return logPriority;
 }
 void
 logstream::setLogLevels( sgDebugClass c, sgDebugPriority p )
 {
    logbuf::set_log_level( c, p );
 }
 logstream *
 logstream::initGlobalLogstream()
 {
    // Force initialization of cerr.
    static std::ios_base::Init initializer;
    if( !global_logstream )
        global_logstream = new logstream(std::cerr);
    return global_logstream;
 }
@@ -1,57 +1,44 @@
-// Stream based logging mechanism.
+/** \file logstream.hxx
-//
+ * Stream based logging mechanism.
 */
 // Written by Bernie Bright, 1998
 //
 // Copyright (C) 1998  Bernie Bright - bbright@c031.aone.net.au
 //
-// This program is free software; you can redistribute it and/or
+// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
+// modify it under the terms of the GNU Library General Public
-// published by the Free Software Foundation; either version 2 of the
+// License as published by the Free Software Foundation; either
-// License, or (at your option) any later version.
+// 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
+// This library is distributed in the hope that it will be useful,
-// WITHOUT ANY WARRANTY; without even the implied warranty of
+// 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.
+// Library 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.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
 #ifndef _LOGSTREAM_H
 #define _LOGSTREAM_H
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <simgear/compiler.h>
-#ifdef FG_HAVE_STD_INCLUDES
+#ifdef _MSC_VER
-# include <streambuf>
+#  include <windows.h>
 # include <iostream>
 #else
 # include <iostream.h>
 # include <simgear/fg_traits.hxx>
 #endif
 #include <streambuf>
 #include <ostream>
 #include <cstdio>
 #include <simgear/debug/debug_types.h>
-#ifndef FG_HAVE_NATIVE_SGI_COMPILERS
+using std::streambuf;
-FG_USING_STD(streambuf);
+using std::ostream;
 FG_USING_STD(ostream);
 FG_USING_STD(cerr);
 FG_USING_STD(endl);
 #endif
 #ifdef __MWERKS__
 #  define cerr std::cerr
 #  define endl std::endl
 FG_USING_STD(iostream);
 #endif
 //
 // TODO:
@@ -61,52 +48,105 @@ FG_USING_STD(iostream);
 // 3. Read environment for default debugClass and debugPriority.
 //
-//-----------------------------------------------------------------------------
+/**
-//
+ * logbuf is an output-only streambuf with the ability to disable sets of
-// logbuf is an output-only streambuf with the ability to disable sets of
+ * messages at runtime. Only messages with priority >= logbuf::logPriority
-// messages at runtime. Only messages with priority >= logbuf::logPriority
+ * and debugClass == logbuf::logClass are output.
-// and debugClass == logbuf::logClass are output.
+ */
-//
+#ifdef SG_NEED_STREAMBUF_HACK
-class logbuf : public streambuf
+class logbuf : public __streambuf
 #else
 class logbuf : public std::streambuf
 #endif
 {
 public:
-
+    // logbuf( streambuf* sb ) : sbuf(sb) {}
-#ifndef FG_HAVE_STD_INCLUDES
+    /** Constructor */
    typedef char_traits<char>           traits_type;
    typedef char_traits<char>::int_type int_type;
    typedef char_traits<char>::pos_type pos_type;
    typedef char_traits<char>::off_type off_type;
 #endif
 //     logbuf( streambuf* sb ) : sbuf(sb) {}
    logbuf();
    /** Destructor */
    ~logbuf();
-    // Is logging enabled?
+    /**
     * Is logging enabled?
     * @return true or false*/
    bool enabled() { return logging_enabled; }
-    // Set the logging level of subsequent messages.
+    /**
-    void set_log_state( fgDebugClass c, fgDebugPriority p );
+     * Set the logging level of subsequent messages.
     * @param c debug class
     * @param p priority
     */
    void set_log_state( sgDebugClass c, sgDebugPriority p );
-    // Set the global logging level.
+    bool would_log( sgDebugClass c, sgDebugPriority p ) const;
    static void set_log_level( fgDebugClass c, fgDebugPriority p );
-    //
+    /**
-    void set_sb( streambuf* sb );
+     * Set the global logging level.
     * @param c debug class
     * @param p priority
     */
    static void set_log_level( sgDebugClass c, sgDebugPriority p );
    /**
     * Set the allowed logging classes.
     * @param c All enabled logging classes anded together.
     */
    static void set_log_classes (sgDebugClass c);
    /**
     * Get the logging classes currently enabled.
     * @return All enabled debug logging anded together.
     */
    static sgDebugClass get_log_classes ();
    /**
     * Set the logging priority.
     * @param c The priority cutoff for logging messages.
     */
    static void set_log_priority (sgDebugPriority p);
    /**
     * Get the current logging priority.
     * @return The priority cutoff for logging messages.
     */
    static sgDebugPriority get_log_priority ();
    /**
     * Set the stream buffer
     * @param sb stream buffer
     */
    void set_sb( std::streambuf* sb );
 #ifdef _MSC_VER
    static void has_no_console() { has_console = false; }
 #endif
 protected:
    /** sync/flush */
    inline virtual int sync();
    /** overflow */
    int_type overflow( int ch );
-//     int xsputn( const char* s, istreamsize n );
+    // int xsputn( const char* s, istreamsize n );
 private:
    // The streambuf used for actual output. Defaults to cerr.rdbuf().
-    static streambuf* sbuf;
+    static std::streambuf* sbuf;
    static bool logging_enabled;
-    static fgDebugClass logClass;
+#ifdef _MSC_VER
-    static fgDebugPriority logPriority;
+    static bool has_console;
 #endif
    static sgDebugClass logClass;
    static sgDebugPriority logPriority;
 private:
@@ -118,103 +158,151 @@ private:
 inline int
 logbuf::sync()
 {
 #ifdef FG_HAVE_STD_INCLUDES
 	return sbuf->pubsync();
 #else
 	return sbuf->sync();
 #endif
 }
 inline void
-logbuf::set_log_state( fgDebugClass c, fgDebugPriority p )
+logbuf::set_log_state( sgDebugClass c, sgDebugPriority p )
 {
    logging_enabled = ((c & logClass) != 0 && p >= logPriority);
 }
 inline bool
 logbuf::would_log( sgDebugClass c, sgDebugPriority p ) const
 {
    return ((c & logClass) != 0 && p >= logPriority);
 }
 inline logbuf::int_type
 logbuf::overflow( int c )
 {
 #ifdef _MSC_VER
    if ( logging_enabled ) {
        if ( !has_console ) {
            AllocConsole();
            freopen("conin$", "r", stdin);
            freopen("conout$", "w", stdout);
            freopen("conout$", "w", stderr);
            has_console = true;
        }
        return sbuf->sputc(c);
    }
    else
        return EOF == 0 ? 1: 0;
 #else
    return logging_enabled ? sbuf->sputc(c) : (EOF == 0 ? 1: 0);
 #endif
 }
-//-----------------------------------------------------------------------------
+/**
-//
+ * logstream manipulator for setting the log level of a message.
-// logstream manipulator for setting the log level of a message.
+ */
 //
 struct loglevel
 {
-    loglevel( fgDebugClass c, fgDebugPriority p )
+    loglevel( sgDebugClass c, sgDebugPriority p )
 	: logClass(c), logPriority(p) {}
-    fgDebugClass logClass;
+    sgDebugClass logClass;
-    fgDebugPriority logPriority;
+    sgDebugPriority logPriority;
 };
-//-----------------------------------------------------------------------------
+/**
-//
+ * A helper class that ensures a streambuf and ostream are constructed and
-// A helper class that ensures a streambuf and ostream are constructed and
+ * destroyed in the correct order.  The streambuf must be created before the
-// destroyed in the correct order.  The streambuf must be created before the
+ * ostream but bases are constructed before members.  Thus, making this class
-// ostream but bases are constructed before members.  Thus, making this class
+ * a private base of logstream, declared to the left of ostream, we ensure the
-// a private base of logstream, declared to the left of ostream, we ensure the
+ * correct order of construction and destruction.
-// correct order of construction and destruction.
+ */
 //
 struct logstream_base
 {
-//     logstream_base( streambuf* sb ) : lbuf(sb) {}
+    // logstream_base( streambuf* sb ) : lbuf(sb) {}
    logstream_base() {}
    logbuf lbuf;
 };
-//-----------------------------------------------------------------------------
+/**
-//
+ * Class to manage the debug logging stream.
-// 
+ */
-//
+class logstream : private logstream_base, public std::ostream
 class logstream : private logstream_base, public ostream
 {
 public:
-    // The default is to send messages to cerr.
+    /**
-    logstream( ostream& out )
+     * The default is to send messages to cerr.
-// 	: logstream_base(out.rdbuf()),
+     * @param out output stream
     */
    logstream( std::ostream& out )
 	// : logstream_base(out.rdbuf()),
 	: logstream_base(),
-	  ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
+	  std::ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
-    void set_output( ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
+    /**
     * Set the output stream
     * @param out output stream
     */
    void set_output( std::ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
-    // Set the global log class and priority level.
+    /**
-     void setLogLevels( fgDebugClass c, fgDebugPriority p );
+     * Set the global log class and priority level.
     * @param c debug class
     * @param p priority
     */
    void setLogLevels( sgDebugClass c, sgDebugPriority p );
-    // Output operator to capture the debug level and priority of a message.
+    bool would_log(  sgDebugClass c, sgDebugPriority p ) const
-    inline ostream& operator<< ( const loglevel& l );
+    {
        return lbuf.would_log( c, p );
    };
    /**
     * Output operator to capture the debug level and priority of a message.
     * @param l log level
     */
    inline std::ostream& operator<< ( const loglevel& l );
    friend logstream& sglog();
    static logstream *initGlobalLogstream();
 protected:
    static logstream *global_logstream;
 };
-inline ostream&
+inline std::ostream&
 logstream::operator<< ( const loglevel& l )
 {
    lbuf.set_log_state( l.logClass, l.logPriority );
    return *this;
 }
-//-----------------------------------------------------------------------------
+/**
-//
+ * \relates logstream
-// Return the one and only logstream instance.
+ * Return the one and only logstream instance.
-// We use a function instead of a global object so we are assured that cerr
+ * We use a function instead of a global object so we are assured that cerr
-// has been initialised.
+ * has been initialised.
-//
+ * @return current logstream
 */
 inline logstream&
-fglog()
+sglog()
 {
-    static logstream logstrm( cerr );
+    return *logstream::initGlobalLogstream();
    return logstrm;
 }
 /** \def SG_LOG(C,P,M)
 * Log a message.
 * @param C debug class
 * @param P priority
 * @param M message
 */
 #ifdef FG_NDEBUG
-# define FG_LOG(C,P,M)
+# define SG_LOG(C,P,M)
 #elif defined( __MWERKS__ )
 # define FG_LOG(C,P,M) ::fglog() << ::loglevel(C,P) << M << std::endl
 #else
-# define FG_LOG(C,P,M) fglog() << loglevel(C,P) << M << endl
+# define SG_LOG(C,P,M) do {                     \
 	logstream& __tmplogstreamref(sglog());                      \
 	if(__tmplogstreamref.would_log(C,P)) {                      \
        __tmplogstreamref << loglevel(C,P) << M << std::endl; } \
 	} while(0)
 #endif
 #define SG_ORIGIN __FILE__ ":" SG_STRINGIZE(__LINE__)
 #endif // _LOGSTREAM_H
@@ -1,23 +1,39 @@
 #include <string>
-#include "Debug/logstream.hxx"
+#include <simgear/debug/logstream.hxx>
 class Test {
 	public:
 	Test() {
 	  //cout << "Cout seems to work" << endl;
 	  //cerr << "Cerr seems to work" << endl;
 	  sglog().setLogLevels( SG_ALL, SG_INFO );
 	  SG_LOG(SG_EVENT, SG_INFO, "Test::Test" << "foo");
 	}
 };
 Test test;
 int
 main( int argc, char* argv[] )
 {
-    fglog().setLogLevels( FG_ALL, FG_INFO );
+    sglog().setLogLevels( SG_ALL, SG_INFO );
-    FG_LOG( FG_TERRAIN, FG_BULK,  "terrain::bulk" ); // shouldnt appear
+    //SG_LOG( FG_TERRAIN, FG_BULK,  "terrain::bulk" ); // shouldnt appear
-    FG_LOG( FG_TERRAIN, FG_DEBUG, "terrain::debug" ); // shouldnt appear
+    //SG_LOG( FG_TERRAIN, SG_DEBUG, "terrain::debug" ); // shouldnt appear
-    FG_LOG( FG_TERRAIN, FG_INFO,  "terrain::info" );
+    //SG_LOG( FG_TERRAIN, SG_INFO,  "terrain::info" );
-    FG_LOG( FG_TERRAIN, FG_WARN,  "terrain::warn" );
+    //SG_LOG( FG_TERRAIN, FG_WARN,  "terrain::warn" );
-    FG_LOG( FG_TERRAIN, FG_ALERT, "terrain::alert" );
+    //SG_LOG( FG_TERRAIN, SG_ALERT, "terrain::alert" );
    int i = 12345;
    long l = 54321L;
    double d = 3.14159;
    string s = "Hello world!";
-    FG_LOG( FG_EVENT, FG_INFO, "event::info "
+    SG_LOG( SG_EVENT, SG_INFO, "event::info "
 				 << "i=" << i
 				 << ", l=" << l
 				 << ", d=" << d
@@ -25,7 +41,7 @@ main( int argc, char* argv[] )
 				 << ", s=\"" << s << "\"" );
    // This shouldn't appear in log output:
-    FG_LOG( FG_EVENT, FG_DEBUG, "event::debug "
+    SG_LOG( SG_EVENT, SG_DEBUG, "event::debug "
 	    << "- this should be seen - "
 	    << "d=" << d
 	    << ", s=\"" << s << "\"" );
@@ -0,0 +1,4 @@
 .deps
 Makefile
 Makefile.in
 metar
@@ -0,0 +1,9 @@
 includedir = @includedir@/environment
 lib_LIBRARIES = libsgenvironment.a
 include_HEADERS = metar.hxx visual_enviro.hxx precipitation.hxx
 libsgenvironment_a_SOURCES = metar.cxx visual_enviro.cxx precipitation.cxx
 INCLUDES = -I$(top_srcdir)
@@ -0,0 +1,278 @@
 // metar interface class
 //
 // Written by Melchior FRANZ, started December 2003.
 //
 // Copyright (C) 2003  Melchior FRANZ - mfranz@aon.at
 //
 // 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
 #ifndef _METAR_HXX
 #define _METAR_HXX
 #include <vector>
 #include <map>
 #include <string>
 #include <simgear/constants.h>
 using std::vector;
 using std::map;
 using std::string;
 const double SGMetarNaN = -1E20;
 #define NaN SGMetarNaN
 struct Token {
 	const char *id;
 	const char *text;
 };
 class SGMetar;
 class SGMetarVisibility {
 	friend class SGMetar;
 public:
 	SGMetarVisibility() :
 		_distance(NaN),
 		_direction(-1),
 		_modifier(EQUALS),
 		_tendency(NONE) {}
 	enum Modifier {
 		NOGO,
 		EQUALS,
 		LESS_THAN,
 		GREATER_THAN
 	};
 	enum Tendency {
 		NONE,
 		STABLE,
 		INCREASING,
 		DECREASING
 	};
 	void set(double dist, int dir = -1, int mod = -1, int tend = -1);
 	inline double	getVisibility_m()	const { return _distance; }
 	inline double	getVisibility_ft()	const { return _distance == NaN ? NaN : _distance * SG_METER_TO_FEET; }
 	inline double	getVisibility_sm()	const { return _distance == NaN ? NaN : _distance * SG_METER_TO_SM; }
 	inline int	getDirection()		const { return _direction; }
 	inline int	getModifier()		const { return _modifier; }
 	inline int	getTendency()		const { return _tendency; }
 protected:
 	double	_distance;
 	int	_direction;
 	int	_modifier;
 	int	_tendency;
 };
 // runway condition (surface and visibility)
 class SGMetarRunway {
 	friend class SGMetar;
 public:
 	SGMetarRunway() :
 		_deposit(-1),
 		_deposit_string(0),
 		_extent(-1),
 		_extent_string(0),
 		_depth(NaN),
 		_friction(NaN),
 		_friction_string(0),
 		_comment(0),
 		_wind_shear(false) {}
 	inline int			getDeposit()		const { return _deposit; }
 	inline const char		*getDepositString()	const { return _deposit_string; }
 	inline double			getExtent()		const { return _extent; }
 	inline const char		*getExtentString()	const { return _extent_string; }
 	inline double			getDepth()		const { return _depth; }
 	inline double			getFriction()		const { return _friction; }
 	inline const char		*getFrictionString()	const { return _friction_string; }
 	inline const char		*getComment()		const { return _comment; }
 	inline const bool		getWindShear()		const { return _wind_shear; }
 	inline const SGMetarVisibility&	getMinVisibility()	const { return _min_visibility; }
 	inline const SGMetarVisibility&	getMaxVisibility()	const { return _max_visibility; }
 protected:
 	SGMetarVisibility _min_visibility;
 	SGMetarVisibility _max_visibility;
 	int		_deposit;
 	const char	*_deposit_string;
 	int		_extent;
 	const char	*_extent_string;
 	double		_depth;
 	double		_friction;
 	const char	*_friction_string;
 	const char	*_comment;
 	bool		_wind_shear;
 };
 // cloud layer
 class SGMetarCloud {
 	friend class SGMetar;
 public:
 	SGMetarCloud() : _coverage(-1), _altitude(NaN), _type(0), _type_long(0) {}
 	void set(double alt, int cov = -1);
 	inline int getCoverage() const { return _coverage; }
 	inline double getAltitude_m() const { return _altitude; }
 	inline double getAltitude_ft() const { return _altitude == NaN ? NaN : _altitude * SG_METER_TO_FEET; }
 	inline const char *getTypeString() const { return _type; }
 	inline const char *getTypeLongString() const { return _type_long; }
 protected:
 	int _coverage;          // quarters: 0 -> clear ... 4 -> overcast
 	double _altitude;       // 1000 m
 	const char *_type;      // CU
 	const char *_type_long; // cumulus
 };
 class SGMetar {
 public:
 	SGMetar(const string& m, const string& proxy = "", const string& port = "",
 			const string &auth = "", const time_t time = 0);
 	~SGMetar();
 	enum ReportType {
 		NONE,
 		AUTO,
 		COR,
 		RTD
 	};
 	inline const char *getData()		const { return _data; }
 	inline const char *getUnusedData()	const { return _m; }
 	inline const bool getProxy()		const { return _x_proxy; }
 	inline const char *getId()		const { return _icao; }
 	inline int	getYear()		const { return _year; }
 	inline int	getMonth()		const { return _month; }
 	inline int	getDay()		const { return _day; }
 	inline int	getHour()		const { return _hour; }
 	inline int	getMinute()		const { return _minute; }
 	inline int	getReportType()		const { return _report_type; }
 	inline int	getWindDir()		const { return _wind_dir; }
 	inline double	getWindSpeed_mps()	const { return _wind_speed; }
 	inline double	getWindSpeed_kmh()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_KMH; }
 	inline double	getWindSpeed_kt()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_KT; }
 	inline double	getWindSpeed_mph()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_MPH; }
 	inline double	getGustSpeed_mps()	const { return _gust_speed; }
 	inline double	getGustSpeed_kmh()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_KMH; }
 	inline double	getGustSpeed_kt()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_KT; }
 	inline double	getGustSpeed_mph()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_MPH; }
 	inline int	getWindRangeFrom()	const { return _wind_range_from; }
 	inline int	getWindRangeTo()	const { return _wind_range_to; }
 	inline const SGMetarVisibility& getMinVisibility()	const { return _min_visibility; }
 	inline const SGMetarVisibility& getMaxVisibility()	const { return _max_visibility; }
 	inline const SGMetarVisibility& getVertVisibility()	const { return _vert_visibility; }
 	inline const SGMetarVisibility *getDirVisibility()	const { return _dir_visibility; }
 	inline double	getTemperature_C()	const { return _temp; }
 	inline double	getTemperature_F()	const { return _temp == NaN ? NaN : 1.8 * _temp + 32; }
 	inline double	getDewpoint_C()		const { return _dewp; }
 	inline double	getDewpoint_F()		const { return _dewp == NaN ? NaN : 1.8 * _dewp + 32; }
 	inline double	getPressure_hPa()	const { return _pressure == NaN ? NaN : _pressure / 100; }
 	inline double	getPressure_inHg()	const { return _pressure == NaN ? NaN : _pressure * SG_PA_TO_INHG; }
 	inline int	getRain()		const { return _rain; }
 	inline int	getHail()		const { return _hail; }
 	inline int	getSnow()		const { return _snow; }
 	inline bool	getCAVOK()		const { return _cavok; }
 	double		getRelHumidity()	const;
 	inline const vector<SGMetarCloud>& getClouds()	const	{ return _clouds; }
 	inline const map<string, SGMetarRunway>& getRunways()	const	{ return _runways; }
 	inline const vector<string>& getWeather()		const	{ return _weather; }
 protected:
 	string	_url;
 	int	_grpcount;
 	bool	_x_proxy;
 	char	*_data;
 	char	*_m;
 	char	_icao[5];
 	int	_year;
 	int	_month;
 	int	_day;
 	int	_hour;
 	int	_minute;
 	int	_report_type;
 	int	_wind_dir;
 	double	_wind_speed;
 	double	_gust_speed;
 	int	_wind_range_from;
 	int	_wind_range_to;
 	double	_temp;
 	double	_dewp;
 	double	_pressure;
 	int	_rain;
 	int	_hail;
 	int	_snow;
 	bool	_cavok;
 	SGMetarVisibility		_min_visibility;
 	SGMetarVisibility		_max_visibility;
 	SGMetarVisibility		_vert_visibility;
 	SGMetarVisibility		_dir_visibility[8];
 	vector<SGMetarCloud>		_clouds;
 	map<string, SGMetarRunway>	_runways;
 	vector<string>			_weather;
 	bool	scanPreambleDate();
 	bool	scanPreambleTime();
 	void	useCurrentDate();
 	bool	scanType();
 	bool	scanId();
 	bool	scanDate();
 	bool	scanModifier();
 	bool	scanWind();
 	bool	scanVariability();
 	bool	scanVisibility();
 	bool	scanRwyVisRange();
 	bool	scanSkyCondition();
 	bool	scanWeather();
 	bool	scanTemperature();
 	bool	scanPressure();
 	bool	scanRunwayReport();
 	bool	scanWindShear();
 	bool	scanTrendForecast();
 	bool	scanColorState();
 	bool	scanRemark();
 	bool	scanRemainder();
 	int	scanNumber(char **str, int *num, int min, int max = 0);
 	bool	scanBoundary(char **str);
 	const struct Token *scanToken(char **str, const struct Token *list);
 	char	*loadData(const char *id, const string& proxy, const string& port,
 			const string &auth, time_t time);
 	void	normalizeData();
 };
 #undef NaN
 #endif // _METAR_HXX
@@ -0,0 +1,181 @@
 /**
 * @file precipitation.cxx
 * @author Nicolas VIVIEN
 * @date 2008-02-10
 *
 * @note Copyright (C) 2008 Nicolas VIVIEN
 *
 * @brief Precipitation effects to draw rain and snow.
 *
 * @par Licences
 *   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */
 #include "precipitation.hxx"
 #include "visual_enviro.hxx"
 #include <simgear/constants.h>
 /**
 * @brief SGPrecipitation constructor
 *
 * Build a new OSG object from osgParticle.
 */
 SGPrecipitation::SGPrecipitation() :
    _freeze(false), _snow_intensity(0.0), _rain_intensity(0.0)
 {
    _precipitationEffect = new osgParticle::PrecipitationEffect;
 }
 /**
 * @brief Build and add the object "precipitationEffect"
 *
 * This function permits you to create an object precipitationEffect and initialize it.
 * I define by default the color of water (for raining)
 */
 osg::Group* SGPrecipitation::build(void)
 {
    osg::Group* group = new osg::Group;
    _precipitationEffect->snow(0);	
    _precipitationEffect->rain(0);	
    group->addChild(_precipitationEffect.get());
    return group;
 }
 /**
 * @brief Define the snow intensity
 *
 * This function permits you to define and change the snow intensity
 * The param 'intensity' is normed (0 to 1).
 */
 void SGPrecipitation::setSnowIntensity(float intensity)
 {
    if (this->_snow_intensity < intensity-0.001)
        this->_snow_intensity += 0.001;
    else if (this->_snow_intensity > intensity+0.001)
        this->_snow_intensity -= 0.001;
    else
        this->_snow_intensity = intensity;
 }
 /**
 * @brief Define the rain intensity
 *
 * This function permits you to define and change the rain intensity
 * The param 'intensity' is normed (0 to 1).
 */
 void SGPrecipitation::setRainIntensity(float intensity)
 {
    if (this->_rain_intensity < intensity-0.001)
        this->_rain_intensity += 0.001;
    else if (this->_rain_intensity > intensity+0.001)
        this->_rain_intensity -= 0.001;
    else
        this->_rain_intensity = intensity;
 }
 /** 
 * @brief Freeze the rain to snow
 * 
 * @param freeze Boolean 
 * 
 * This function permits you to turn off the rain to snow.
 */
 void SGPrecipitation::setFreezing(bool freeze)
 {
    this->_freeze = freeze;
 }
 /**
 * @brief Define the wind direction and speed
 *
 * This function permits you to define and change the wind direction
 * 
 * After apply the MatrixTransform to the osg::Precipitation object,
 * x points full south... From wind heading and speed, we can calculate
 * the wind vector.
 */
 void SGPrecipitation::setWindProperty(double heading, double speed)
 {
    double x, y, z;
    heading = (heading + 180) * SGD_DEGREES_TO_RADIANS;
    speed = speed * SG_FEET_TO_METER;
    x = -cos(heading) * speed;
    y = sin(heading) * speed;
    z = 0;
    this->_wind_vec = osg::Vec3(x, y, z);
 }
 /**
 * @brief Update the precipitation effects
 *
 * This function permits you to update the precipitation effects.
 * Be careful, if snow and rain intensity are greater than '0', snow effect
 * will be first.
 *
 * The settings come from the osgParticule/PrecipitationEffect.cpp exemple.
 */
 bool SGPrecipitation::update(void)
 {
    if (this->_freeze) {
        if (this->_rain_intensity > 0) 
            this->_snow_intensity = this->_rain_intensity;
    }
    bool enabled = sgEnviro.get_precipitation_enable_state();
    if (enabled && this->_snow_intensity > 0) {
        _precipitationEffect->setWind(_wind_vec);
        _precipitationEffect->setParticleSpeed( -0.75f - 0.25f*_snow_intensity);
        _precipitationEffect->setParticleSize(0.02f + 0.03f*_snow_intensity);
        _precipitationEffect->setMaximumParticleDensity(_snow_intensity * 7.2f);
        _precipitationEffect->setCellSize(osg::Vec3(5.0f / (0.25f+_snow_intensity), 5.0f / (0.25f+_snow_intensity), 5.0f));
        _precipitationEffect->setNearTransition(25.f);
        _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_snow_intensity));
        _precipitationEffect->setParticleColor(osg::Vec4(0.85, 0.85, 0.85, 1.0) - osg::Vec4(0.1, 0.1, 0.1, 1.0) * _snow_intensity);
    } else if (enabled && this->_rain_intensity > 0) {
        _precipitationEffect->setWind(_wind_vec);
        _precipitationEffect->setParticleSpeed( -2.0f + -5.0f*_rain_intensity);
        _precipitationEffect->setParticleSize(0.01 + 0.02*_rain_intensity);
        _precipitationEffect->setMaximumParticleDensity(_rain_intensity * 7.5f);
        _precipitationEffect->setCellSize(osg::Vec3(5.0f / (0.25f+_rain_intensity), 5.0f / (0.25f+_rain_intensity), 5.0f));
        _precipitationEffect->setNearTransition(25.f);
        _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_rain_intensity));
        _precipitationEffect->setParticleColor( osg::Vec4(0x7A, 0xCE, 0xFF, 0x80));
    } else {
        _precipitationEffect->snow(0);	
        _precipitationEffect->rain(0);	
    }
    return true;
 }
@@ -0,0 +1,60 @@
 /**
 * @file precipitation.hxx
 * @author Nicolas VIVIEN
 * @date 2008-02-10
 *
 * @note Copyright (C) 2008 Nicolas VIVIEN
 *
 * @brief Precipitation effects to draw rain and snow.
 *
 * @par Licences
 *   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */
 #ifndef _PRECIPITATION_HXX
 #define _PRECIPITATION_HXX
 #include <osg/Group>
 #include <osg/Referenced>
 #include <osgParticle/PrecipitationEffect>
 class SGPrecipitation : public osg::Referenced
 {
 private:
    bool _freeze;
    float _snow_intensity;
    float _rain_intensity;
    int _wind_dir;
    osg::Vec3 _wind_vec;
    osg::ref_ptr<osgParticle::PrecipitationEffect> _precipitationEffect;
 public:
    SGPrecipitation();
    virtual ~SGPrecipitation() {}
    osg::Group* build(void);
    bool update(void);
    void setWindProperty(double, double);
    void setFreezing(bool);
    void setRainIntensity(float);
    void setSnowIntensity(float);
 };
 #endif
@@ -0,0 +1,798 @@
 // Visual environment helper class
 //
 // Written by Harald JOHNSEN, started April 2005.
 //
 // Copyright (C) 2005  Harald JOHNSEN - hjohnsen@evc.net
 //
 // 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/constants.h>
 #include <simgear/structure/SGReferenced.hxx>
 #include <simgear/structure/SGSharedPtr.hxx>
 #include <simgear/math/sg_random.h>
 #include <simgear/math/sg_geodesy.hxx>
 #include <simgear/math/point3d.hxx>
 #include <simgear/math/polar3d.hxx>
 #include <simgear/sound/sample_group.hxx>
 #include <simgear/scene/sky/cloudfield.hxx>
 #include <simgear/scene/sky/newcloud.hxx>
 #include <simgear/props/props.hxx>
 #include "visual_enviro.hxx"
 #include <vector>
 using std::vector;
 typedef struct {
 	Point3D		pt;
 	int			depth;
 	int			prev;
 } lt_tree_seg;
 #define MAX_RAIN_SLICE	200
 static float rainpos[MAX_RAIN_SLICE];
 #define MAX_LT_TREE_SEG	400
 #define DFL_MIN_LIGHT 0.35
 sgVec3 SGEnviro::min_light = {DFL_MIN_LIGHT, DFL_MIN_LIGHT, DFL_MIN_LIGHT};
 #define DFL_STREAK_BRIGHT_NEARMOST_LAYER 0.9
 SGfloat SGEnviro::streak_bright_nearmost_layer = DFL_STREAK_BRIGHT_NEARMOST_LAYER;
 #define DFL_STREAK_BRIGHT_FARMOST_LAYER 0.5
 SGfloat SGEnviro::streak_bright_farmost_layer = DFL_STREAK_BRIGHT_FARMOST_LAYER;
 #define DFL_STREAK_PERIOD_MAX 2.5
 SGfloat SGEnviro::streak_period_max = DFL_STREAK_PERIOD_MAX;
 #define DFL_STREAK_PERIOD_CHANGE_PER_KT 0.005
 SGfloat SGEnviro::streak_period_change_per_kt = DFL_STREAK_PERIOD_CHANGE_PER_KT;
 #define DFL_STREAK_PERIOD_MIN 1.0
 SGfloat SGEnviro::streak_period_min = DFL_STREAK_PERIOD_MIN;
 #define DFL_STREAK_LENGTH_MIN 0.03
 SGfloat SGEnviro::streak_length_min = DFL_STREAK_LENGTH_MIN;
 #define DFL_STREAK_LENGTH_CHANGE_PER_KT 0.0005
 SGfloat SGEnviro::streak_length_change_per_kt = DFL_STREAK_LENGTH_CHANGE_PER_KT;
 #define DFL_STREAK_LENGTH_MAX 0.1
 SGfloat SGEnviro::streak_length_max = DFL_STREAK_LENGTH_MAX;
 #define DFL_STREAK_COUNT_MIN 40
 int SGEnviro::streak_count_min = DFL_STREAK_COUNT_MIN;
 #define DFL_STREAK_COUNT_MAX 190
 #if (DFL_STREAK_COUNT_MAX > MAX_RAIN_SLICE)
 #error "Bad default!"
 #endif
 int SGEnviro::streak_count_max = DFL_STREAK_COUNT_MAX;
 #define DFL_CONE_BASE_RADIUS 15.0
 SGfloat SGEnviro::cone_base_radius = DFL_CONE_BASE_RADIUS;
 #define DFL_CONE_HEIGHT 30.0
 SGfloat SGEnviro::cone_height = DFL_CONE_HEIGHT;
 void SGEnviro::config(const SGPropertyNode* n)
 {
 	if (!n)
 		return;
 	const float ml = n->getFloatValue("min-light", DFL_MIN_LIGHT);
 	sgSetVec3(min_light, ml, ml, ml);
 	streak_bright_nearmost_layer = n->getFloatValue(
 			"streak-brightness-nearmost-layer",
 			DFL_STREAK_BRIGHT_NEARMOST_LAYER);
 	streak_bright_farmost_layer = n->getFloatValue(
 			"streak-brightness-farmost-layer",
 			DFL_STREAK_BRIGHT_FARMOST_LAYER);
 	streak_period_max = n->getFloatValue(
 			"streak-period-max",
 			DFL_STREAK_PERIOD_MAX);
 	streak_period_min = n->getFloatValue(
 			"streak-period-min",
 			DFL_STREAK_PERIOD_MIN);
 	streak_period_change_per_kt = n->getFloatValue(
 			"streak-period-change-per-kt",
 			DFL_STREAK_PERIOD_CHANGE_PER_KT);
 	streak_length_max = n->getFloatValue(
 			"streak-length-max",
 			DFL_STREAK_LENGTH_MAX);
 	streak_length_min = n->getFloatValue(
 			"streak-length-min",
 			DFL_STREAK_LENGTH_MIN);
 	streak_length_change_per_kt = n->getFloatValue(
 			"streak-length-change-per-kt",
 			DFL_STREAK_LENGTH_CHANGE_PER_KT);
 	streak_count_min = n->getIntValue(
 			"streak-count-min", DFL_STREAK_COUNT_MIN);
 	streak_count_max = n->getIntValue(
 			"streak-count-max", DFL_STREAK_COUNT_MAX);
 	if (streak_count_max > MAX_RAIN_SLICE)
 		streak_count_max = MAX_RAIN_SLICE;
 	cone_base_radius = n->getFloatValue(
 			"cone-base-radius", DFL_CONE_BASE_RADIUS);
 	cone_height = n->getFloatValue("cone_height", DFL_CONE_HEIGHT);
 }
 /**
 * A class to render lightnings.
 */
 class SGLightning {
 public:
    /**
     * Build a new lightning.
     * The lightning has a limited life time. It will also play a thunder sounder once.
     * @param lon lon longitude in degree
     * @param lat lat latitude in degree
     * @param alt asl of top of lightning
     */
 	SGLightning(double lon, double lat, double alt);
 	~SGLightning();
 	void lt_Render(void);
 	void lt_build(void);
 	void lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize);
 	// contains all the segments of the lightning
 	lt_tree_seg lt_tree[MAX_LT_TREE_SEG];
 	// segment count
 	int		nb_tree;
 	// position of lightning
 	double	lon, lat, alt;
 	int		sequence_count;
 	// time to live
 	double	age;
 };
 typedef vector<SGLightning *> list_of_lightning;
 static list_of_lightning lightnings;
 SGEnviro sgEnviro;
 SGEnviro::SGEnviro() :
 	view_in_cloud(false),
 	precipitation_enable_state(true),
 	precipitation_density(100.0),
 	precipitation_max_alt(0.0),
 	turbulence_enable_state(false),
 	last_cloud_turbulence(0.0),
 	cloud_turbulence(0.0),
 	lightning_enable_state(false),
 	elapsed_time(0.0),
 	dt(0.0),
 	sampleGroup(NULL),
 	snd_active(false),
 	snd_dist(0.0),
 	min_time_before_lt(0.0),
 	fov_width(55.0),
 	fov_height(55.0)
 {
 	for(int i = 0; i < MAX_RAIN_SLICE ; i++)
 		rainpos[i] = sg_random();
 	radarEcho.reserve(100);
 }
 SGEnviro::~SGEnviro(void) {
 	if (sampleGroup) delete sampleGroup;
  // OSGFIXME
  return;
 	list_of_lightning::iterator iLightning;
 	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
 		delete (*iLightning);
 	}
 	lightnings.clear();
 }
 void SGEnviro::startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time) {
  // OSGFIXME
  return;
 	view_in_cloud = false;
 	// ask the impostor cache to do some cleanup
 	last_cloud_turbulence = cloud_turbulence;
 	cloud_turbulence = 0.0;
 	elapsed_time += delta_time;
 	min_time_before_lt -= delta_time;
 	dt = delta_time;
 	sgMat4 T1, LON, LAT;
    sgVec3 axis;
    sgMakeTransMat4( T1, p );
    sgSetVec3( axis, 0.0, 0.0, 1.0 );
    sgMakeRotMat4( LON, lon, axis );
    sgSetVec3( axis, 0.0, 1.0, 0.0 );
    sgMakeRotMat4( LAT, 90.0 - lat, axis );
    sgMat4 TRANSFORM;
    sgCopyMat4( TRANSFORM, T1 );
    sgPreMultMat4( TRANSFORM, LON );
    sgPreMultMat4( TRANSFORM, LAT );
    sgCoord pos;
    sgSetCoord( &pos, TRANSFORM );
 	sgMakeCoordMat4( transform, &pos );
    last_lon = lon;
    last_lat = lat;
 	last_alt = alt;
 	radarEcho.clear();
 	precipitation_max_alt = 400.0;
 }
 void SGEnviro::endOfFrame(void) {
 }
 double SGEnviro::get_cloud_turbulence(void) const {
 	return last_cloud_turbulence;
 }
 // this can be queried to add some turbulence for example
 bool SGEnviro::is_view_in_cloud(void) const {
 	return view_in_cloud;
 }
 void SGEnviro::set_view_in_cloud(bool incloud) {
 	view_in_cloud = incloud;
 }
 bool SGEnviro::get_turbulence_enable_state(void) const {
 	return turbulence_enable_state;
 }
 void SGEnviro::set_turbulence_enable_state(bool enable) {
 	turbulence_enable_state = enable;
 }
 // rain/snow
 float SGEnviro::get_precipitation_density(void) const {
 	return precipitation_density;
 }
 bool SGEnviro::get_precipitation_enable_state(void) const {
 	return precipitation_enable_state;
 }
 void SGEnviro::set_precipitation_density(float density) {
 	precipitation_density = density;
 }
 void SGEnviro::set_precipitation_enable_state(bool enable) {
 	precipitation_enable_state = enable;
 }
 // others
 bool SGEnviro::get_lightning_enable_state(void) const {
 	return lightning_enable_state;
 }
 void SGEnviro::set_lightning_enable_state(bool enable) {
 	lightning_enable_state = enable;
 	if( ! enable ) {
 		// TODO:cleanup
 	}
 }
 void SGEnviro::setLight(sgVec4 adj_fog_color) {
  // OSGFIXME
  return;
 	sgCopyVec4( fog_color, adj_fog_color );
 	if( false ) {
 	//    ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
 	}
 }
 #if 0
 void SGEnviro::callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId) {
 	// send data to wx radar
 	// compute turbulence
 	// draw precipitation
 	// draw lightning
 	// compute illumination
 	// http://www.pilotfriend.com/flight_training/weather/THUNDERSTORM%20HAZARDS1.htm
 	double turbulence = 0.0;
 	if( dist < radius * radius * 2.25f ) {
 		switch(family) {
 			case SGNewCloud::CLFamilly_st:
 				turbulence = 0.2;
 				break;
 			case SGNewCloud::CLFamilly_ci:
 			case SGNewCloud::CLFamilly_cs:
 			case SGNewCloud::CLFamilly_cc:
 			case SGNewCloud::CLFamilly_ac:
 			case SGNewCloud::CLFamilly_as:
 				turbulence = 0.1;
 				break;
 			case SGNewCloud::CLFamilly_sc:
 				turbulence = 0.3;
 				break;
 			case SGNewCloud::CLFamilly_ns:
 				turbulence = 0.4;
 				break;
 			case SGNewCloud::CLFamilly_cu:
 				turbulence = 0.5;
 				break;
 			case SGNewCloud::CLFamilly_cb:
 				turbulence = 0.6;
 				break;
 		}
 		// full turbulence inside cloud, half in the vicinity
 		if( dist > radius * radius )
 			turbulence *= 0.5;
 		if( turbulence > cloud_turbulence )
 			cloud_turbulence = turbulence;
 		// we can do 'local' precipitations too
 	}
 	// convert to LWC for radar (experimental)
 	// http://www-das.uwyo.edu/~geerts/cwx/notes/chap08/moist_cloud.html
 	double LWC = 0.0;
 	switch(family) {
 		case SGNewCloud::CLFamilly_st:
 			LWC = 0.29;
 			break;
 		case SGNewCloud::CLFamilly_cu:
 			LWC = 0.27;
 			break;
 		case SGNewCloud::CLFamilly_cb:
 			LWC = 2.0;
 			break;
 		case SGNewCloud::CLFamilly_sc:
 			LWC = 0.44;
 			break;
 		case SGNewCloud::CLFamilly_ci:
 			LWC = 0.03;
 			break;
 		// no data
 		case SGNewCloud::CLFamilly_cs:
 		case SGNewCloud::CLFamilly_cc:
 		case SGNewCloud::CLFamilly_ac:
 		case SGNewCloud::CLFamilly_as:
 			LWC = 0.03;
 			break;
 		case SGNewCloud::CLFamilly_ns:
 			LWC = 0.29*2.0;
 			break;
 	}
 	// add to the list for the wxRadar instrument
 	if( LWC > 0.0 )
 		radarEcho.push_back( SGWxRadarEcho ( heading, alt, radius, dist, LWC, false, cloudId ) );
 	// NB:data valid only from cockpit view
 	// spawn a new lightning
 	if(lightning_enable_state && min_time_before_lt <= 0.0 && (family == SGNewCloud::CLFamilly_cb) &&
 		dist < 15000.0 * 15000.0 && sg_random() > 0.9f) {
 		double lat, lon;
 		Point3D orig, dest;
 		orig.setlat(last_lat * SG_DEGREES_TO_RADIANS );
 		orig.setlon(last_lon * SG_DEGREES_TO_RADIANS );
 		orig.setelev(0.0);
 		dist = sgSqrt(dist);
 		dest = calc_gc_lon_lat(orig, heading, dist);
 		lon = dest.lon() * SG_RADIANS_TO_DEGREES;
 		lat = dest.lat() * SG_RADIANS_TO_DEGREES;
 		addLightning( lon, lat, alt );
 		// reset timer
 		min_time_before_lt = 5.0 + sg_random() * 30;
 		// DEBUG only
 //		min_time_before_lt = 5.0;
 	}
 	if( (alt - radius * 0.1) > precipitation_max_alt )
 		switch(family) {
 			case SGNewCloud::CLFamilly_st:
 			case SGNewCloud::CLFamilly_cu:
 			case SGNewCloud::CLFamilly_cb:
 			case SGNewCloud::CLFamilly_ns:
 			case SGNewCloud::CLFamilly_sc:
 				precipitation_max_alt = alt - radius * 0.1;
 				break;
 		}
 }
 #endif
 list_of_SGWxRadarEcho *SGEnviro::get_radar_echo(void) {
 	return &radarEcho;
 }
 // precipitation rendering code
 void SGEnviro::DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed) {
  // OSGFIXME
  return;
 	sgVec3 light;
 	sgAddVec3( light, fog_color, min_light );
 	float da = SG_PI * 2.0f / (float) slices;
 	// low number = faster
 	float speedf = streak_period_max - speed * streak_period_change_per_kt;
 	if( speedf < streak_period_min )
 		speedf = streak_period_min;
 	float lenf = streak_length_min + speed * streak_length_change_per_kt;
 	if( lenf > streak_length_max )
 		lenf = streak_length_max;
    float t = fmod((float) elapsed_time, speedf) / speedf;
 //	t = 0.1f;
 	if( !down )
 		t = 1.0f - t;
 	float angle = 0.0f;
 	//glColor4f(1.0f, 0.7f, 0.7f, 0.9f); // XXX unneeded? overriden below
 	glBegin(GL_LINES);
 	if (slices >  MAX_RAIN_SLICE)
 		slices = MAX_RAIN_SLICE; // should never happen
 	for( int i = 0 ; i < slices ; i++ ) {
 		float x = cos(angle) * baseRadius;
 		float y = sin(angle) * baseRadius;
 		angle += da;
 		sgVec3 dir = {x, -height, y};
 		// rain drops at 2 different speed to simulate depth
 		float t1 = (i & 1 ? t : t + t) + rainpos[i];
 		if(t1 > 1.0f)	t1 -= 1.0f;
 		if(t1 > 1.0f)	t1 -= 1.0f;
 		// distant raindrops are more transparent
 		float c = t1 * (i & 1 ?
 				streak_bright_farmost_layer
 				: streak_bright_nearmost_layer);
 		glColor4f(c * light[0], c * light[1], c * light[2], c);
 		sgVec3 p1, p2;
 		sgScaleVec3(p1, dir, t1);
 		// distant raindrops are shorter
 		float t2 = t1 + (i & 1 ? lenf : lenf+lenf);
 		sgScaleVec3(p2, dir, t2);
 		glVertex3f(p1[0], p1[1] + height, p1[2]);
 		glVertex3f(p2[0], p2[1] + height, p2[2]);
 	}
 	glEnd();
 }
 void SGEnviro::drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm) {
  // OSGFIXME
  return;
 #if 0
 	static int debug_period = 0;
 	if (debug_period++ == 50) {
 		debug_period = 0;
 		cout << "drawRain("
 			<< pitch << ", "
 			<< roll  << ", "
 			<< heading << ", "
 			<< hspeed << ", "
 			<< rain_norm << ");"
 			//" angle = " << angle
 			//<< " raindrop(KTS) = " << raindrop_speed_kts
 			<< endl;
 	}
 #endif
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glDisable(GL_DEPTH_TEST);
 	glShadeModel(GL_SMOOTH);
 	glEnable(GL_BLEND);
 	glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
 	glDisable( GL_FOG );
 	glDisable(GL_LIGHTING);
 	int slice_count = static_cast<int>(
 			(streak_count_min + rain_norm*(streak_count_max-streak_count_min))
 				* precipitation_density / 100.0);
 	// www.wonderquest.com/falling-raindrops.htm says that
 	// Raindrop terminal velocity is 5 to 20mph
 	// Rather than model it accurately (temp, pressure, diameter), and make it
 	// smaller than terminal when closer to the precipitation cloud base,
 	// we interpolate in the 5-20mph range according to rain_norm.
 	double raindrop_speed_kts
 		= (5.0 + rain_norm*15.0) * SG_MPH_TO_MPS * SG_MPS_TO_KT;
 	float angle = atanf(hspeed / raindrop_speed_kts) * SG_RADIANS_TO_DEGREES;
 	glPushMatrix();
 		// the cone rotate with hspeed
 		angle = -pitch - angle;
 		glRotatef(roll, 0.0, 0.0, 1.0);
 		glRotatef(heading, 0.0, 1.0, 0.0);
 		glRotatef(angle, 1.0, 0.0, 0.0);
 		// up cone
 		DrawCone2(cone_base_radius, cone_height, 
 				slice_count, true, rain_norm, hspeed);
 		// down cone (usually not visible)
 		if(angle > 0.0 || heading != 0.0)
 			DrawCone2(cone_base_radius, -cone_height, 
 					slice_count, false, rain_norm, hspeed);
 	glPopMatrix();
 	glEnable(GL_LIGHTING);
 	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
 	glEnable( GL_FOG );
 	glEnable(GL_DEPTH_TEST);
 }
 void SGEnviro::set_sampleGroup(SGSampleGroup *sgr) {
 	sampleGroup = sgr;
 }
 void SGEnviro::drawPrecipitation(double rain_norm, double snow_norm, double hail_norm, double pitch, double roll, double heading, double hspeed) {
  // OSGFIXME
  return;
 	if( precipitation_enable_state && rain_norm > 0.0)
 	  if( precipitation_max_alt >= last_alt )
 		drawRain(pitch, roll, heading, hspeed, rain_norm);
 }
 SGLightning::SGLightning(double _lon, double _lat, double _alt) :
 	nb_tree(0),
 	lon(_lon),
 	lat(_lat),
 	alt(_alt),
 	age(1.0 + sg_random() * 4.0)
 {
 //	sequence_count = 1 + sg_random() * 5.0;
 	lt_build();
 }
 SGLightning::~SGLightning() {
 }
 // lightning rendering code
 void SGLightning::lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize) {
  // OSGFIXME
  return;
 	sgVec3 dir, newdir;
 	int nseg = 0;
 	Point3D pt = start;
 	if( nbseg == 50 )
 		sgSetVec3( dir, 0.0, -1.0, 0.0 );
 	else {
 		sgSetVec3( dir, sg_random() - 0.5f, sg_random() - 0.5f, sg_random() - 0.5f);
 		sgNormaliseVec3(dir);
 	}
 	if( nb_tree >= MAX_LT_TREE_SEG )
 		return;
 	lt_tree[nb_tree].depth = tree_nr;
 	nseg = 0;
 	lt_tree[nb_tree].pt = pt;
 	lt_tree[nb_tree].prev = -1;
 	nb_tree ++;
 	// TODO:check agl
 	while(nseg < nbseg && pt.y() > 0.0) {
        int prev = nb_tree - 1;
        nseg++;
 		// add a branch
        if( energy * sg_random() > 0.8f )
 			lt_build_tree_branch(tree_nr + 1, pt, energy * 0.9f, nbseg == 50 ? 10 : static_cast<int>(nbseg * 0.4f), segsize * 0.7f);
 		if( nb_tree >= MAX_LT_TREE_SEG )
 			return;
 		sgSetVec3(newdir, (sg_random() - 0.5f), (sg_random() - 0.5f) - (nbseg == 50 ? 0.5f : 0.0), (sg_random() - 0.5f));
 		sgNormaliseVec3(newdir);
 		sgAddVec3( dir, newdir);
 		sgNormaliseVec3(dir);
 		sgVec3 scaleDir;
 		sgScaleVec3( scaleDir, dir, segsize * energy * 0.5f );
 		pt[PX] += scaleDir[0];
 		pt[PY] += scaleDir[1];
 		pt[PZ] += scaleDir[2];
 		lt_tree[nb_tree].depth = tree_nr;
 		lt_tree[nb_tree].pt = pt;
 		lt_tree[nb_tree].prev = prev;
 		nb_tree ++;
 	}
 }
 void SGLightning::lt_build(void) {
  // OSGFIXME
  return;
    Point3D top;
    nb_tree = 0;
    top[PX] = 0 ;
    top[PY] = alt;
    top[PZ] = 0;
    lt_build_tree_branch(0, top, 1.0, 50, top[PY] / 8.0);
 	if( ! sgEnviro.sampleGroup )
 		return;
 	Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
 	Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
 	double course = 0.0, dist = 0.0;
 	calc_gc_course_dist( dest, start, &course, &dist );
 	if( dist < 10000.0 && ! sgEnviro.snd_playing && (dist < sgEnviro.snd_dist || ! sgEnviro.snd_active) ) {
 		sgEnviro.snd_timer = 0.0;
 		sgEnviro.snd_wait  = dist / 340;
 		sgEnviro.snd_dist  = dist;
 		sgEnviro.snd_pos_lat = lat;
 		sgEnviro.snd_pos_lon = lon;
 		sgEnviro.snd_active = true;
 		sgEnviro.snd_playing = false;
 	}
 }
 void SGLightning::lt_Render(void) {
  // OSGFIXME
  return;
 	float flash = 0.5;
 	if( fmod(sgEnviro.elapsed_time*100.0, 100.0) > 50.0 )
 		flash = sg_random() * 0.75f + 0.25f;
    float h = lt_tree[0].pt[PY];
 	sgVec4 col={0.62f, 0.83f, 1.0f, 1.0f};
 	sgVec4 c;
 #define DRAW_SEG() \
 			{glColorMaterial(GL_FRONT, GL_EMISSION);  \
 			glDisable(GL_LINE_SMOOTH); glBegin(GL_LINES); \
 				glColor4fv(c); \
                glVertex3f(lt_tree[n].pt[PX], lt_tree[n].pt[PZ], lt_tree[n].pt[PY]); \
                glVertex3f(lt_tree[lt_tree[n].prev].pt[PX], lt_tree[lt_tree[n].prev].pt[PZ], lt_tree[lt_tree[n].prev].pt[PY]); \
 			glEnd(); glEnable(GL_LINE_SMOOTH);}
 	glDepthMask( GL_FALSE );
 	glEnable(GL_BLEND);
 	glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glDisable(GL_LIGHTING);
 	glDisable( GL_FOG );
 	glPushMatrix();
 	sgMat4 modelview, tmp;
    // OSGFIXME
 //     ssgGetModelviewMatrix( modelview );
 	sgCopyMat4( tmp, sgEnviro.transform );
    sgPostMultMat4( tmp, modelview );
    // OSGFIXME
 //     ssgLoadModelviewMatrix( tmp );
    Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
    Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
    double course = 0.0, dist = 0.0;
    calc_gc_course_dist( dest, start, &course, &dist );
    double ax = 0.0, ay = 0.0;
    ax = cos(course) * dist;
    ay = sin(course) * dist;
 	glTranslatef( ax, ay, -sgEnviro.last_alt );
 	sgEnviro.radarEcho.push_back( SGWxRadarEcho ( course, 0.0, 0.0, dist, age, true, 0 ) );
 	for( int n = 0 ; n < nb_tree ; n++ ) {
        if( lt_tree[n].prev < 0 )
 			continue;
        float t1 = sgLerp(0.5, 1.0, lt_tree[n].pt[PY] / h);
 		t1 *= flash;
 		if( lt_tree[n].depth >= 2 ) {
            glLineWidth(3);
 			sgScaleVec4(c, col, t1 * 0.6f);
 			DRAW_SEG();
 		} else {
 			if( lt_tree[n].depth == 0 ) {
                glLineWidth(12);
 				sgScaleVec4(c, col, t1 * 0.5f);
 				DRAW_SEG();
                glLineWidth(6);
 				sgScaleVec4(c, col, t1);
 				DRAW_SEG();
 			} else {
                glLineWidth(6);
 				sgScaleVec4(c, col, t1 * 0.7f);
 				DRAW_SEG();
 			}
            if( lt_tree[n].depth == 0 ) 
                glLineWidth(3);
 			else
                glLineWidth(2);
            sgSetVec4(c, t1, t1, t1, t1);
 			DRAW_SEG();
 		}
 	}
    glLineWidth(1);
 	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
 	glPopMatrix();
 	glDepthMask( GL_TRUE );	
 	glEnable( GL_FOG );
 	glEnable(GL_LIGHTING);
 }
 void SGEnviro::addLightning(double lon, double lat, double alt) {
  // OSGFIXME
  return;
 	if( lightnings.size() > 10)
 		return;
 	SGLightning *lt= new SGLightning(lon, lat, alt);
 	lightnings.push_back(lt);
 }
 void SGEnviro::drawLightning(void) {
  // OSGFIXME
  return;
 	list_of_lightning::iterator iLightning;
 	// play 'thunder' for lightning
 	if( snd_active ) {
 		if( !snd_playing ) {
 			// wait until sound has reached us
 			snd_timer += dt;
 			if( snd_timer >= snd_wait ) {
 				snd_playing = true;
 				// compute relative position of lightning
 				Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
 				Point3D dest( snd_pos_lon*SG_DEGREES_TO_RADIANS, snd_pos_lat*SG_DEGREES_TO_RADIANS, 0.0 );
 				double course = 0.0, dist = 0.0;
 				calc_gc_course_dist( dest, start, &course, &dist );
 				double ax = 0.0, ay = 0.0;
 				ax = cos(course) * dist;
 				ay = sin(course) * dist;
 				SGSharedPtr<SGSoundSample> snd = sampleGroup->find("thunder");
 				if( snd ) {
 					SGVec3d pos = SGVec3d(ax, ay, -sgEnviro.last_alt);
 					snd->set_position(pos);
 					snd->play_once();
 				}
 			}
 		} else {
 			if( !sampleGroup->is_playing("thunder") ) {
 				snd_active = false;
 				snd_playing = false;
 			}
 		}
 	}
 	if( ! lightning_enable_state )
 		return;
 	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
 		if( dt )
 			if( sg_random() > 0.95f )
 				(*iLightning)->lt_build();
 		(*iLightning)->lt_Render();
 		(*iLightning)->age -= dt;
 		if( (*iLightning)->age < 0.0 ) {
 			delete (*iLightning);
 			lightnings.erase( iLightning );
 			break;
 		}
 	}
 }
 void SGEnviro::setFOV( float w, float h ) {
 	fov_width = w;
 	fov_height = h;
 }
 void SGEnviro::getFOV( float &w, float &h ) {
 	w = fov_width;
 	h = fov_height;
 }
@@ -0,0 +1,258 @@
 // Visual environment helper class
 //
 // Written by Harald JOHNSEN, started April 2005.
 //
 // Copyright (C) 2005  Harald JOHNSEN - hjohnsen@evc.net
 //
 // 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 //
 #ifndef _VISUAL_ENVIRO_HXX
 #define _VISUAL_ENVIRO_HXX
 #include <plib/sg.h>
 #include <simgear/compiler.h>
 #include <string>
 #include <vector>
 using std::vector;
 using std::string;
 class SGLightning;
 class SGSampleGroup;
 /**
 * Simulate some echo on a weather radar.
 * Container class for the wx radar instrument.
 */
 class SGWxRadarEcho {
 public:
 	SGWxRadarEcho(float _heading, float _alt, float _radius, float _dist,
 			double _LWC, bool _lightning, int _cloudId ) :
 	  heading( _heading ),
 	  alt ( _alt ),
 	  radius ( _radius ),
 	  dist ( _dist ),
 	  LWC ( _LWC ),
 	  lightning ( _lightning ),
 	  cloudId ( _cloudId )
 	{}
 	/** the heading in radian is versus north */
 	float heading;
 	float alt, radius, dist;
 	/** reflectivity converted to liquid water content. */
 	double LWC;
 	/** if true then this data is for a lightning else it is for water echo. */
 	bool lightning;
 	/** Unique identifier of cloud */
 	int cloudId;
 };
 typedef vector<SGWxRadarEcho> list_of_SGWxRadarEcho;
 /**
 * Visual environment helper class.
 */
 class SGEnviro {
 friend class SGLightning;
 private:
 	void DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed);
 	void lt_update(void);
 	bool view_in_cloud;
 	bool precipitation_enable_state;
 	float precipitation_density;
 	float precipitation_max_alt;
 	bool turbulence_enable_state;
 	double last_cloud_turbulence, cloud_turbulence;
 	bool lightning_enable_state;
 	double elapsed_time, dt;
 	sgVec4	fog_color;
 	sgMat4 transform;
 	double last_lon, last_lat, last_alt;
 	SGSampleGroup	*sampleGroup;
 	bool		snd_active, snd_playing;
 	double		snd_timer, snd_wait, snd_pos_lat, snd_pos_lon, snd_dist;
 	double		min_time_before_lt;
 	float fov_width, fov_height;
 	/** a list of all the radar echo. */
 	list_of_SGWxRadarEcho radarEcho;
 	static sgVec3 min_light;
 	static SGfloat streak_bright_nearmost_layer,
 				   streak_bright_farmost_layer,
 				   streak_period_max,
 				   streak_period_change_per_kt,
 				   streak_period_min,
 				   streak_length_min,
 				   streak_length_change_per_kt,
 				   streak_length_max;
 	static int streak_count_min, streak_count_max;
 	static SGfloat cone_base_radius,
 				   cone_height;
 public:
 	SGEnviro();
 	~SGEnviro();
 	/** Read the config from the precipitation rendering config properties.
 	 * @param precip_rendering_cfgNode "/sim/rendering/precipitation" in fg
 	 * Set from whatever info present in the
 	 * subnodes passed, substituting hardwired defaults for missing fields.
 	 * If NULL is given, do nothing.
 	 */
 	void config(const class SGPropertyNode* precip_rendering_cfgNode);
    /**
     * Forward a few states used for renderings.
     */
 	void startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time);
 	void endOfFrame(void);
 #if 0
    /**
     * Whenever a cloud is drawn we check his 'impact' on the environment.
     * @param heading direction of cloud in radians
     * @param alt asl of cloud in meters
     * @param radius radius of cloud in meters
     * @param family cloud family
     * @param dist  squared dist to cloud in meters
     */
 	void callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId);
 #endif
 	void drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm);
    /**
     * Draw rain or snow precipitation around the viewer.
     * @param rain_norm rain normalized intensity given by metar class
     * @param snow_norm snow normalized intensity given by metar class
     * @param hail_norm hail normalized intensity given by metar class
     * @param pitch pitch rotation of viewer
     * @param roll roll rotation of viewer
     * @param hspeed moving horizontal speed of viewer in kt
     */
 	void drawPrecipitation(double rain_norm, double snow_norm, double hail_norm,
 							double pitch, double roll, double heading, double hspeed);
    /**
     * Draw the lightnings spawned by cumulo nimbus.
     */
 	void drawLightning(void);
    /**
     * Forward the fog color used by the rain rendering.
     * @param adj_fog_color color of the fog
     */
 	void setLight(sgVec4 adj_fog_color);
 	// this can be queried to add some turbulence for example
 	bool is_view_in_cloud(void) const;
 	void set_view_in_cloud(bool incloud);
 	double get_cloud_turbulence(void) const;
 	// Clouds
 	// return the size of the memory pool used by texture impostors
 	int get_clouds_CacheSize(void) const;
 	int get_CacheResolution(void) const;
 	float get_clouds_visibility(void) const;
 	float get_clouds_density(void) const;
 	bool get_clouds_enable_state(void) const;
 	bool get_turbulence_enable_state(void) const;
    /**
     * Set the size of the impostor texture cache for 3D clouds.
     * @param sizeKb size of the texture pool in Kb
     */
 	void set_clouds_CacheSize(int sizeKb);
    /**
     * Set the resolution of the impostor texture for 3D clouds.
     * @param resolutionPixels size of each texture in pixels (64|128|256)
     */
 	void set_CacheResolution(int resolutionPixels);
    /**
     * Set the maximum range used when drawing clouds.
 	 * Clouds are blended from totaly transparent at max range to totaly opaque around the viewer
     * @param distance in meters
     */
 	void set_clouds_visibility(float distance);
    /**
     * Set the proportion of clouds that will be rendered to limit drop in FPS.
     * @param density 0..100 no clouds drawn when density == 0, all are drawn when density == 100
     */
 	void set_clouds_density(float density);
    /**
     * Enable or disable the use of 3D clouds.
     * @param enable when false we draw the 2D layers
     */
 	void set_clouds_enable_state(bool enable);
    /**
     * Enable or disable the use of proximity cloud turbulence.
     * @param enable when true the turbulence is computed based on type of cloud around the AC
     */
 	void set_turbulence_enable_state(bool enable);
 	// rain/snow
 	float get_precipitation_density(void) const;
 	bool get_precipitation_enable_state(void) const;
 	/** 
 	 * Decrease the precipitation density to the given percentage.
 	 * (Only show the given percentage of rain streaks etc.)
 	 * Default precipitation density upon construction is 100.0.
 	 * @param density 0.0 to 100.0
 	 */
 	void set_precipitation_density(float density);
    /**
     * Enable or disable the rendering of precipitation around the viewer.
     * @param enable when true we will draw precipitation depending on metar data
     */
 	void set_precipitation_enable_state(bool enable);
 	// others
 	bool get_lightning_enable_state(void) const;
    /**
     * Enable or disable the rendering of lightning and the thunder sound.
     * @param enable when true we will draw lightning spwaned by cumulonimbus
     */
 	void set_lightning_enable_state(bool enable);
    /**
     * Spawn a new lighning at specified lon/lat.
     * @param lon position of the new lightning
     * @param lat position of the new lightning
     * @param alt asl of the starting point of the lightning in meters
     */
 	void addLightning(double lon, double lat, double alt);
    /**
     * Forward the sound manager instance to be able to play samples.
     * @param mgr a running sound manager
     */
 	void set_sampleGroup(SGSampleGroup *sgr);
 	void setFOV( float w, float h );
 	void getFOV( float &w, float &h );
 	list_of_SGWxRadarEcho *get_radar_echo(void);
 	sgMat4 *get_transform(void) { return &transform; }
 };
 extern SGEnviro sgEnviro;
 #endif // _VISUAL_ENVIRO_HXX
@@ -0,0 +1,3 @@
 .deps
 Makefile
 Makefile.in
@@ -1,18 +1,34 @@
-noinst_LIBRARIES = libEphemeris.a
+includedir = @includedir@/ephemeris
-libEphemeris_a_SOURCES = \
+lib_LIBRARIES = libsgephem.a
-	celestialBody.cxx celestialBody.hxx \
+
-	ephemeris.cxx ephemeris.hxx \
+include_HEADERS = \
-	jupiter.cxx jupiter.hxx \
+	celestialBody.hxx \
-	mars.cxx mars.hxx \
+	ephemeris.hxx \
-	mercury.cxx mercury.hxx \
+	jupiter.hxx \
-	moon.cxx moon.hxx \
+	mars.hxx \
-	neptune.cxx neptune.hxx \
+	mercury.hxx \
 	moonpos.hxx \
 	neptune.hxx \
 	saturn.hxx \
 	star.hxx \
 	stardata.hxx \
 	uranus.hxx \
 	venus.hxx
 libsgephem_a_SOURCES = \
 	celestialBody.cxx \
 	ephemeris.cxx \
 	jupiter.cxx \
 	mars.cxx \
 	mercury.cxx \
 	moonpos.cxx \
 	neptune.cxx \
 	pluto.hxx \
-	saturn.cxx saturn.hxx \
+	saturn.cxx \
-	star.cxx star.hxx \
+	star.cxx \
-	stars.cxx stars.hxx \
+	stardata.cxx \
-	uranus.cxx uranus.hxx \
+	uranus.cxx \
-	venus.cxx venus.hxx
+	venus.cxx
-INCLUDES += -I$(top_builddir) -I$(top_builddir)/src
+INCLUDES = -I$(top_srcdir)
@@ -5,28 +5,25 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #include <simgear/debug/logstream.hxx>
 #ifdef FG_MATH_EXCEPTION_CLASH
 #  define exception c_exception
 #endif
 #include <math.h>
 #include "celestialBody.hxx"
@@ -34,7 +31,7 @@
 /**************************************************************************
- * void CelestialBody::updatePosition(fgTIME *t, Star *ourSun)
+ * void CelestialBody::updatePosition(double mjd, Star *ourSun)
 *
 * Basically, this member function provides a general interface for 
 * calculating the right ascension and declinaion. This function is 
@@ -45,25 +42,25 @@
 * position is calculated an a slightly different manner.  
 *
 * arguments:
- * fgTIME t: provides the current time.
+ * double mjd: provides the modified julian date.
 * Star *ourSun: the sun's position is needed to convert heliocentric 
 *               coordinates into geocentric coordinates.
 *
 * return value: none
 *
 *************************************************************************/
-void CelestialBody::updatePosition(FGTime *t, Star *ourSun)
+void CelestialBody::updatePosition(double mjd, Star *ourSun)
 {
  double eccAnom, v, ecl, actTime, 
    xv, yv, xh, yh, zh, xg, yg, zg, xe, ye, ze;
-  updateOrbElements(t);
+  updateOrbElements(mjd);
-  actTime = fgCalcActTime(t);
+  actTime = sgCalcActTime(mjd);
  // calcualate the angle bewteen ecliptic and equatorial coordinate system
-  ecl = DEG_TO_RAD * (23.4393 - 3.563E-7 *actTime);
+  ecl = SGD_DEGREES_TO_RADIANS * (23.4393 - 3.563E-7 *actTime);
-  eccAnom = fgCalcEccAnom(M, e);  //calculate the eccentric anomaly
+  eccAnom = sgCalcEccAnom(M, e);  //calculate the eccentric anomaly
  xv = a * (cos(eccAnom) - e);
  yv = a * (sqrt (1.0 - e*e) * sin(eccAnom));
  v = atan2(yv, xv);           // the planet's true anomaly
@@ -87,7 +84,7 @@ void CelestialBody::updatePosition(FGTime *t, Star *ourSun)
  ze = yg * sin(ecl) + zg * cos(ecl);
  rightAscension = atan2(ye, xe);
  declination = atan2(ze, sqrt(xe*xe + ye*ye));
-  /* FG_LOG(FG_GENERAL, FG_INFO, "Planet found at : " 
+  /* SG_LOG(SG_GENERAL, SG_INFO, "Planet found at : " 
 	 << rightAscension << " (ra), " << declination << " (dec)" ); */
  //calculate some variables specific to calculating the magnitude 
@@ -106,11 +103,11 @@ void CelestialBody::updatePosition(FGTime *t, Star *ourSun)
      tmp = -1.0;
  }
-  FV = RAD_TO_DEG * acos( tmp );
+  FV = SGD_RADIANS_TO_DEGREES * acos( tmp );
-};
+}
 /****************************************************************************
- * double CelestialBody::fgCalcEccAnom(double M, double e)
+ * double CelestialBody::sgCalcEccAnom(double M, double e)
 * this private member calculates the eccentric anomaly of a celestial body, 
 * given its mean anomaly and eccentricity.
 * 
@@ -135,7 +132,7 @@ void CelestialBody::updatePosition(FGTime *t, Star *ourSun)
 * the eccentric anomaly
 *
 ****************************************************************************/
-double CelestialBody::fgCalcEccAnom(double M, double e)
+double CelestialBody::sgCalcEccAnom(double M, double e)
 {
  double 
    eccAnom, E0, E1, diff;
@@ -151,28 +148,118 @@ double CelestialBody::fgCalcEccAnom(double M, double e)
 	  diff = fabs(E0 - E1);
 	  E0 = E1;
 	}
-      while (diff > (DEG_TO_RAD * 0.001));
+      while (diff > (SGD_DEGREES_TO_RADIANS * 0.001));
      return E0;
    }
  return eccAnom;
 }
-
+/*****************************************************************************
-
+ * inline CelestialBody::CelestialBody
-
+ * public constructor for a generic celestialBody object.
-
+ * initializes the 6 primary orbital elements. The elements are:
-
+ * N: longitude of the ascending node
-
+ * i: inclination to the ecliptic
-
+ * w: argument of perihelion
-
+ * a: semi-major axis, or mean distance from the sun
-
+ * e: eccenticity
-
+ * M: mean anomaly
-
+ * Each orbital element consists of a constant part and a variable part that 
-
+ * gradually changes over time. 
-
+ *
-
+ * Argumetns:
-
+ * the 13 arguments to the constructor constitute the first, constant 
-
+ * ([NiwaeM]f) and the second variable ([NiwaeM]s) part of the orbital 
-
+ * elements. The 13th argument is the current time. Note that the inclination
 * is written with a capital (If, Is), because 'if' is a reserved word in the 
 * C/C++ programming language.
 ***************************************************************************/ 
 CelestialBody::CelestialBody(double Nf, double Ns,
 				    double If, double Is,
 				    double wf, double ws,
 				    double af, double as,
 				    double ef, double es,
 				    double Mf, double Ms, double mjd)
 {
  NFirst = Nf;     NSec = Ns;
  iFirst = If;     iSec = Is;
  wFirst = wf;     wSec = ws;
  aFirst = af;     aSec = as;
  eFirst = ef;     eSec = es;
  MFirst = Mf;     MSec = Ms;
  updateOrbElements(mjd);
 }
 CelestialBody::CelestialBody(double Nf, double Ns,
 				    double If, double Is,
 				    double wf, double ws,
 				    double af, double as,
 				    double ef, double es,
 				    double Mf, double Ms)
 {
  NFirst = Nf;     NSec = Ns;
  iFirst = If;     iSec = Is;
  wFirst = wf;     wSec = ws;
  aFirst = af;     aSec = as;
  eFirst = ef;     eSec = es;
  MFirst = Mf;     MSec = Ms;
 }
 /****************************************************************************
 * inline void CelestialBody::updateOrbElements(double mjd)
 * given the current time, this private member calculates the actual 
 * orbital elements
 *
 * Arguments: double mjd: the current modified julian date:
 *
 * return value: none
 ***************************************************************************/
 void CelestialBody::updateOrbElements(double mjd)
 {
  double actTime = sgCalcActTime(mjd);
   M = SGD_DEGREES_TO_RADIANS * (MFirst + (MSec * actTime));
   w = SGD_DEGREES_TO_RADIANS * (wFirst + (wSec * actTime));
   N = SGD_DEGREES_TO_RADIANS * (NFirst + (NSec * actTime));
   i = SGD_DEGREES_TO_RADIANS * (iFirst + (iSec * actTime));
   e = eFirst + (eSec * actTime);
   a = aFirst + (aSec * actTime);
 }
 /*****************************************************************************
 * inline double CelestialBody::sgCalcActTime(double mjd)
 * this private member function returns the offset in days from the epoch for
 * wich the orbital elements are calculated (Jan, 1st, 2000).
 * 
 * Argument: the current time
 *
 * return value: the (fractional) number of days until Jan 1, 2000.
 ****************************************************************************/
 double CelestialBody::sgCalcActTime(double mjd)
 {
  return (mjd - 36523.5);
 }
 /*****************************************************************************
 * inline void CelestialBody::getPos(double* ra, double* dec)
 * gives public access to Right Ascension and declination
 *
 ****************************************************************************/
 void CelestialBody::getPos(double* ra, double* dec)
 {
  *ra  = rightAscension;
  *dec = declination;
 }
 /*****************************************************************************
 * inline void CelestialBody::getPos(double* ra, double* dec, double* magnitude
 * gives public acces to the current Right ascension, declination, and 
 * magnitude
 ****************************************************************************/
 void CelestialBody::getPos(double* ra, double* dec, double* magn)
 {
  *ra = rightAscension;
  *dec = declination;
  *magn = magnitude;
 }
@@ -5,19 +5,19 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
@@ -33,8 +33,6 @@
 #include <simgear/constants.h>
 #include <Time/fg_time.hxx>
 class Star;
 class CelestialBody
@@ -61,9 +59,9 @@ protected:              // make the data protected, in order to give the
  double magnitude;
  double lonEcl, latEcl;
-  double fgCalcEccAnom(double M, double e);
+  double sgCalcEccAnom(double M, double e);
-  double fgCalcActTime(FGTime *t);
+  double sgCalcActTime(double mjd);
-  void updateOrbElements(FGTime *t);
+  void updateOrbElements(double mjd);
 public:
  CelestialBody(double Nf, double Ns,
@@ -71,7 +69,7 @@ public:
 		double wf, double ws,
 		double af, double as,
 		double ef, double es,
-		double Mf, double Ms, FGTime *t);
+		double Mf, double Ms, double mjd);
  CelestialBody(double Nf, double Ns,
 		double If, double Is,
 		double wf, double ws,
@@ -85,116 +83,9 @@ public:
  double getMagnitude();
  double getLon();
  double getLat(); 
-  void updatePosition(FGTime *t, Star *ourSun);
+  void updatePosition(double mjd, Star *ourSun);
 };
 /*****************************************************************************
 * inline CelestialBody::CelestialBody
 * public constructor for a generic celestialBody object.
 * initializes the 6 primary orbital elements. The elements are:
 * N: longitude of the ascending node
 * i: inclination to the ecliptic
 * w: argument of perihelion
 * a: semi-major axis, or mean distance from the sun
 * e: eccenticity
 * M: mean anomaly
 * Each orbital element consists of a constant part and a variable part that 
 * gradually changes over time. 
 *
 * Argumetns:
 * the 13 arguments to the constructor constitute the first, constant 
 * ([NiwaeM]f) and the second variable ([NiwaeM]s) part of the orbital 
 * elements. The 13th argument is the current time. Note that the inclination
 * is written with a capital (If, Is), because 'if' is a reserved word in the 
 * C/C++ programming language.
 ***************************************************************************/ 
 inline CelestialBody::CelestialBody(double Nf, double Ns,
 				    double If, double Is,
 				    double wf, double ws,
 				    double af, double as,
 				    double ef, double es,
 				    double Mf, double Ms, FGTime *t)
 {
  NFirst = Nf;     NSec = Ns;
  iFirst = If;     iSec = Is;
  wFirst = wf;     wSec = ws;
  aFirst = af;     aSec = as;
  eFirst = ef;     eSec = es;
  MFirst = Mf;     MSec = Ms;
  updateOrbElements(t);
 };
 inline CelestialBody::CelestialBody(double Nf, double Ns,
 				    double If, double Is,
 				    double wf, double ws,
 				    double af, double as,
 				    double ef, double es,
 				    double Mf, double Ms)
 {
  NFirst = Nf;     NSec = Ns;
  iFirst = If;     iSec = Is;
  wFirst = wf;     wSec = ws;
  aFirst = af;     aSec = as;
  eFirst = ef;     eSec = es;
  MFirst = Mf;     MSec = Ms;
 };
 /****************************************************************************
 * inline void CelestialBody::updateOrbElements(FGTime *t)
 * given the current time, this private member calculates the actual 
 * orbital elements
 *
 * Arguments: FGTime *t: the current time:
 *
 * return value: none
 ***************************************************************************/
 inline void CelestialBody::updateOrbElements(FGTime *t)
 {
  double actTime = fgCalcActTime(t);
   M = DEG_TO_RAD * (MFirst + (MSec * actTime));
   w = DEG_TO_RAD * (wFirst + (wSec * actTime));
   N = DEG_TO_RAD * (NFirst + (NSec * actTime));
   i = DEG_TO_RAD * (iFirst + (iSec * actTime));
   e = eFirst + (eSec * actTime);
   a = aFirst + (aSec * actTime);
 }
 /*****************************************************************************
 * inline double CelestialBody::fgCalcActTime(FGTime *t)
 * this private member function returns the offset in days from the epoch for
 * wich the orbital elements are calculated (Jan, 1st, 2000).
 * 
 * Argument: the current time
 *
 * return value: the (fractional) number of days until Jan 1, 2000.
 ****************************************************************************/
 inline double CelestialBody::fgCalcActTime(FGTime *t)
 {
  return (t->getMjd() - 36523.5);
 }
 /*****************************************************************************
 * inline void CelestialBody::getPos(double* ra, double* dec)
 * gives public access to Right Ascension and declination
 *
 ****************************************************************************/
 inline void CelestialBody::getPos(double* ra, double* dec)
 {
  *ra  = rightAscension;
  *dec = declination;
 }
 /*****************************************************************************
 * inline void CelestialBody::getPos(double* ra, double* dec, double* magnitude
 * gives public acces to the current Right ascension, declination, and 
 * magnitude
 ****************************************************************************/
 inline void CelestialBody::getPos(double* ra, double* dec, double* magn)
 {
  *ra = rightAscension;
  *dec = declination;
  *magn = magnitude;
 }
 inline double CelestialBody::getRightAscension() { return rightAscension; }
 inline double CelestialBody::getDeclination() { return declination; }
 inline double CelestialBody::getMagnitude() { return magnitude; }
@@ -211,14 +102,3 @@ inline double CelestialBody::getLat()
 #endif // _CELESTIALBODY_H_
@@ -3,32 +3,37 @@
 //
 // Written by Curtis Olson, started March 2000.
 //
-// Copyright (C) 2000  Curtis L. Olson - curt@flightgear.org
+// Copyright (C) 2000  Curtis L. Olson - http://www.flightgear.org/~curt
 //
-// This program is free software; you can redistribute it and/or
+// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
+// modify it under the terms of the GNU Library General Public
-// published by the Free Software Foundation; either version 2 of the
+// License as published by the Free Software Foundation; either
-// License, or (at your option) any later version.
+// 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
+// This library is distributed in the hope that it will be useful,
-// WITHOUT ANY WARRANTY; without even the implied warranty of
+// 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.
+// Library 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.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <iostream>
 #include "ephemeris.hxx"
 // Constructor
-FGEphemeris::FGEphemeris( const string &path ) {
+SGEphemeris::SGEphemeris( const std::string &path ) {
    our_sun = new Star;
-    moon = new Moon;
+    moon = new MoonPos;
    mercury = new Mercury;
    venus = new Venus;
    mars = new Mars;
@@ -36,12 +41,15 @@ FGEphemeris::FGEphemeris( const string &path ) {
    saturn = new Saturn;
    uranus = new Uranus;
    neptune = new Neptune;
-    stars = new FGStars( FGPath(path) );
+    nplanets = 7;
    for ( int i = 0; i < nplanets; ++i )
      planets[i] = SGVec3d::zeros();
    stars = new SGStarData( SGPath(path) );
 }
 // Destructor
-FGEphemeris::~FGEphemeris( void ) {
+SGEphemeris::~SGEphemeris( void ) {
    delete our_sun;
    delete moon;
    delete mercury;
@@ -57,17 +65,17 @@ FGEphemeris::~FGEphemeris( void ) {
 // Update (recalculate) the positions of all objects for the specified
 // time
-void FGEphemeris::update( FGTime *t, double lat ) {
+void SGEphemeris::update( double mjd, double lst, double lat ) {
    // update object positions
-    our_sun->updatePosition( t );
+    our_sun->updatePosition( mjd );
-    moon->updatePosition( t, lat, our_sun );
+    moon->updatePosition( mjd, lst, lat, our_sun );
-    mercury->updatePosition( t, our_sun );
+    mercury->updatePosition( mjd, our_sun );
-    venus->updatePosition( t, our_sun );
+    venus->updatePosition( mjd, our_sun );
-    mars->updatePosition( t, our_sun );
+    mars->updatePosition( mjd, our_sun );
-    jupiter->updatePosition( t, our_sun );
+    jupiter->updatePosition( mjd, our_sun );
-    saturn->updatePosition( t, our_sun );
+    saturn->updatePosition( mjd, our_sun );
-    uranus->updatePosition( t, our_sun );
+    uranus->updatePosition( mjd, our_sun );
-    neptune->updatePosition( t, our_sun );
+    neptune->updatePosition( mjd, our_sun );
    // update planets list
    nplanets = 7;
@@ -1,23 +1,27 @@
-// ephemeris.hxx -- Top level class for calculating current positions of
+/** \file ephemeris.hxx
-//                  astronomical objects
+ * Top level class for calculating current positions of astronomical objects.
 */
 // Top level interface written by Curtis Olson, started March 2000.
 //
-// Written by Curtis Olson, started March 2000.
+// All the core code underneath this is written by Durk Talsma.  See
 // the headers of all the other individual files for details.
 //
-// Copyright (C) 2000  Curtis L. Olson - curt@flightgear.org
+// Copyright (C) 2000  Curtis L. Olson - http://www.flightgear.org/~curt
 //
-// This program is free software; you can redistribute it and/or
+// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
+// modify it under the terms of the GNU Library General Public
-// published by the Free Software Foundation; either version 2 of the
+// License as published by the Free Software Foundation; either
-// License, or (at your option) any later version.
+// 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
+// This library is distributed in the hope that it will be useful,
-// WITHOUT ANY WARRANTY; without even the implied warranty of
+// 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.
+// Library 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.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
@@ -25,31 +29,49 @@
 #ifndef _EPHEMERIS_HXX
 #define _EPHEMERIS_HXX
 #include <string>
-#ifdef HAVE_CONFIG_H
+#include <simgear/ephemeris/star.hxx>
-#  include <config.h>
+#include <simgear/ephemeris/moonpos.hxx>
-#endif
+#include <simgear/ephemeris/mercury.hxx>
 #include <simgear/ephemeris/venus.hxx>
 #include <simgear/ephemeris/mars.hxx>
 #include <simgear/ephemeris/jupiter.hxx>
 #include <simgear/ephemeris/saturn.hxx>
 #include <simgear/ephemeris/uranus.hxx>
 #include <simgear/ephemeris/neptune.hxx>
 #include <simgear/ephemeris/stardata.hxx>
-#include <plib/sg.h>
+#include <simgear/math/SGMath.hxx>
-
+#include <simgear/misc/sg_path.hxx>
 #include <Time/fg_time.hxx>
 #include "star.hxx"
 #include "moon.hxx"
 #include "mercury.hxx"
 #include "venus.hxx"
 #include "mars.hxx"
 #include "jupiter.hxx"
 #include "saturn.hxx"
 #include "uranus.hxx"
 #include "neptune.hxx"
 #include "stars.hxx"
-class FGEphemeris {
+/** Ephemeris class
 *
 * Written by Durk Talsma <d.talsma@direct.a2000.nl> and Curtis Olson
 * <http://www.flightgear.org/~curt>
 *
 * Introduction 
 *
 * The SGEphemeris class computes and stores the positions of the Sun,
 * the Moon, the planets, and the brightest stars.  These positions
 * can then be used to accurately render the dominant visible items in
 * the Earth's sky. Note, this class isn't intended for use in an
 * interplanetary/interstellar/intergalactic type application. It is
 * calculates everything relative to the Earth and is therefore best
 * suited for Earth centric applications.
 *
 * The positions of the various astronomical objects are time
 * dependent, so to maintain accuracy, you will need to periodically
 * call the update() method. The SGTime class conveniently provides
 * the two time related values you need to pass to the update()
 * method.
 */
 class SGEphemeris {
    Star *our_sun;
-    Moon *moon;
+    MoonPos *moon;
    Mercury *mercury;
    Venus *venus;
    Mars *mars;
@@ -63,47 +85,93 @@ class FGEphemeris {
    // planets[i][1] = Declination
    // planets[i][2] = Magnitude
    int nplanets;
-    sgdVec3 planets[7];
+    SGVec3d planets[7];
-    FGStars *stars;
+    SGStarData *stars;
 public:
-    // Constructor
+    /**
-    FGEphemeris( const string &path );
+     * Constructor.
     * This creates an instance of the SGEphemeris object. When
     * calling the constructor you need to provide a path pointing to
     * your star database file.
     * @param path path to your star database */
    SGEphemeris( const std::string &path );
-    // Destructor
+    /** Destructor */
-    ~FGEphemeris( void );
+    ~SGEphemeris( void );
-    // Update (recalculate) the positions of all objects for the
+    /**
-    // specified time
+     * Update (recalculate) the positions of all objects for the
-    void update(FGTime *t, double lat);
+     * specified time.  The update() method requires you to pass in
     * the current modified Julian date, the current local sidereal
     * time, and the current latitude. The update() method is designed
     * to be called by the host application before every frame.
     * @param mjd modified julian date
     * @param lst current local sidereal time
     * @param lat current latitude
     */
    void update(double mjd, double lst, double lat);
-    // sun
+    /**
     * @return a pointer to a Star class containing all the positional
     * information for Earth's Sun.
     */
    inline Star *get_sun() const { return our_sun; }
    /** @return the right ascension of the Sun. */
    inline double getSunRightAscension() const {
 	return our_sun->getRightAscension();
    }
    /** @return the declination of the Sun. */
    inline double getSunDeclination() const {
 	return our_sun->getDeclination();
    }
-    // moon
+    /**
-    inline Moon *get_moon() const { return moon; }
+     * @return a pointer to a Moon class containing all the positional
     * information for Earth's Moon.
     */
    inline MoonPos *get_moon() const { return moon; }
    /** @return the right ascension of the Moon. */
    inline double getMoonRightAscension() const {
 	return moon->getRightAscension();
    }
    /** @return the declination of the Moon. */
    inline double getMoonDeclination() const {
 	return moon->getDeclination();
    }
-    // planets
+    /** @return the numbers of defined planets. */
    inline int getNumPlanets() const { return nplanets; }
    inline sgdVec3 *getPlanets() { return planets; }
-    // planets
+    /**
     * Returns a pointer to an array of planet data in sgdVec3
     * format. (See plib.sourceforge.net for information on plib and
     * the ``sg'' package.) An sgdVec3 is a 3 element double
     * array. The first element is the right ascension of the planet,
     * the second is the declination, and the third is the magnitude.
     * @return planets array
     */
    inline SGVec3d *getPlanets() { return planets; }
    inline const SGVec3d *getPlanets() const { return planets; }
    /** @return the numbers of defined stars. */
    inline int getNumStars() const { return stars->getNumStars(); }
-    inline sgdVec3 *getStars() { return stars->getStars(); }
+
    /**
     * Returns a pointer to an array of star data in sgdVec3
     * format. An The first element of the sgdVec3 is the right
     * ascension of the planet, the second is the declination, and the
     * third is the magnitude.
     * @returns star array
     */
    inline SGVec3d *getStars() { return stars->getStars(); }
    inline const SGVec3d *getStars() const { return stars->getStars(); }
 };
@@ -5,45 +5,41 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifdef __BORLANDC__
 #  define exception c_exception
 #endif
 #include <math.h>
 #include "jupiter.hxx"
 /*************************************************************************
- * Jupiter::Jupiter(FGTime *t)
+ * Jupiter::Jupiter(double mjd)
 * Public constructor for class Jupiter
 * Argument: The current time.
 * the hard coded orbital elements for Jupiter are passed to 
 * CelestialBody::CelestialBody();
 ************************************************************************/
-Jupiter::Jupiter(FGTime *t) :
+Jupiter::Jupiter(double mjd) :
  CelestialBody(100.4542,  2.7685400E-5,	
 		1.3030,   -1.557E-7,
 		273.8777,  1.6450500E-5,
 		5.2025600, 0.000000,
 		0.048498,  4.469E-9,
-		19.89500,  0.08308530010, t)
+		19.89500,  0.08308530010, mjd)
 {
 }
@@ -58,15 +54,15 @@ Jupiter::Jupiter() :
 }
 /*************************************************************************
- * void Jupiter::updatePosition(FGTime *t, Star *ourSun)
+ * void Jupiter::updatePosition(double mjd, Star *ourSun)
 * 
 * calculates the current position of Jupiter, by calling the base class,
 * CelestialBody::updatePosition(); The current magnitude is calculated using 
 * a Jupiter specific equation
 *************************************************************************/
-void Jupiter::updatePosition(FGTime *t, Star *ourSun)
+void Jupiter::updatePosition(double mjd, Star *ourSun)
 {
-  CelestialBody::updatePosition(t, ourSun);
+  CelestialBody::updatePosition(mjd, ourSun);
  magnitude = -9.25 + 5*log10( r*R ) + 0.014 * FV;
 }
@@ -5,35 +5,34 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifndef _JUPITER_HXX_
 #define _JUPITER_HXX_
-#include <Time/fg_time.hxx>
+#include <simgear/ephemeris/celestialBody.hxx>
-#include "celestialBody.hxx"
+#include <simgear/ephemeris/star.hxx>
 #include "star.hxx"
 class Jupiter : public CelestialBody
 {
 public:
-  Jupiter (FGTime *t);
+  Jupiter (double mjd);
  Jupiter ();
-  void updatePosition(FGTime *t, Star *ourSun);
+  void updatePosition(double mjd, Star *ourSun);
 };
 #endif // _JUPITER_HXX_
@@ -5,44 +5,41 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifdef __BORLANDC__
 #  define exception c_exception
 #endif
 #include <math.h>
 #include "mars.hxx"
 /*************************************************************************
- * Mars::Mars(FGTime *t)
+ * Mars::Mars(double mjd)
 * Public constructor for class Mars
 * Argument: The current time.
 * the hard coded orbital elements for Mars are passed to 
 * CelestialBody::CelestialBody();
 ************************************************************************/
-Mars::Mars(FGTime *t) :
+Mars::Mars(double mjd) :
  CelestialBody(49.55740,  2.1108100E-5,
 		1.8497,   -1.78E-8,
 		286.5016,  2.9296100E-5,
 		1.5236880, 0.000000,
 		0.093405,  2.516E-9,
-		18.60210,  0.52402077660, t)
+		18.60210,  0.52402077660, mjd)
 {
 }
 Mars::Mars() :
@@ -55,14 +52,14 @@ Mars::Mars() :
 {
 }
 /*************************************************************************
- * void Mars::updatePosition(FGTime *t, Star *ourSun)
+ * void Mars::updatePosition(double mjd, Star *ourSun)
 * 
 * calculates the current position of Mars, by calling the base class,
 * CelestialBody::updatePosition(); The current magnitude is calculated using 
 * a Mars specific equation
 *************************************************************************/
-void Mars::updatePosition(FGTime *t, Star *ourSun)
+void Mars::updatePosition(double mjd, Star *ourSun)
 {
-  CelestialBody::updatePosition(t, ourSun);
+  CelestialBody::updatePosition(mjd, ourSun);
  magnitude = -1.51 + 5*log10( r*R ) + 0.016 * FV;
 }
@@ -5,35 +5,34 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifndef _MARS_HXX_
 #define _MARS_HXX_
-#include <Time/fg_time.hxx>
+#include <simgear/ephemeris/celestialBody.hxx>
-#include "celestialBody.hxx"
+#include <simgear/ephemeris/star.hxx>
 #include "star.hxx"
 class Mars : public CelestialBody
 {
 public:
-  Mars ( FGTime *t);
+  Mars ( double mjd );
  Mars ();
-  void updatePosition(FGTime *t, Star *ourSun);
+  void updatePosition(double mjd, Star *ourSun);
 };
 #endif // _MARS_HXX_
@@ -5,44 +5,41 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifdef __BORLANDC__
 #  define exception c_exception
 #endif
 #include <math.h>
 #include "mercury.hxx"
 /*************************************************************************
- * Mercury::Mercury(FGTime *t)
+ * Mercury::Mercury(double mjd)
 * Public constructor for class Mercury
 * Argument: The current time.
 * the hard coded orbital elements for Mercury are passed to 
 * CelestialBody::CelestialBody();
 ************************************************************************/
-Mercury::Mercury(FGTime *t) :
+Mercury::Mercury(double mjd) :
  CelestialBody (48.33130,   3.2458700E-5,
                  7.0047,    5.00E-8,
                  29.12410,  1.0144400E-5,
                  0.3870980, 0.000000,
                  0.205635,  5.59E-10,
-                  168.6562,  4.09233443680, t)
+                  168.6562,  4.09233443680, mjd)
 {
 }
 Mercury::Mercury() :
@@ -55,15 +52,15 @@ Mercury::Mercury() :
 {
 }
 /*************************************************************************
- * void Mercury::updatePosition(FGTime *t, Star *ourSun)
+ * void Mercury::updatePosition(double mjd, Star *ourSun)
 * 
 * calculates the current position of Mercury, by calling the base class,
 * CelestialBody::updatePosition(); The current magnitude is calculated using 
 * a Mercury specific equation
 *************************************************************************/
-void Mercury::updatePosition(FGTime *t, Star *ourSun)
+void Mercury::updatePosition(double mjd, Star *ourSun)
 {
-  CelestialBody::updatePosition(t, ourSun);
+  CelestialBody::updatePosition(mjd, ourSun);
  magnitude = -0.36 + 5*log10( r*R ) + 0.027 * FV + 2.2E-13 * pow(FV, 6); 
 }
@@ -5,35 +5,34 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
 #ifndef _MERCURY_HXX_
 #define _MERCURY_HXX_
-#include <Time/fg_time.hxx>
+#include <simgear/ephemeris/celestialBody.hxx>
-#include "celestialBody.hxx"
+#include <simgear/ephemeris/star.hxx>
 #include "star.hxx"
 class Mercury : public CelestialBody
 {
 public:
-  Mercury ( FGTime *t);
+  Mercury (double mjd);
  Mercury ();
-  void updatePosition(FGTime *t, Star* ourSun);
+  void updatePosition(double mjd, Star* ourSun);
 };
 #endif // _MERURY_HXX_
@@ -1,23 +1,23 @@
 /**************************************************************************
- * moon.cxx
+ * moonpos.cxx
 * Written by Durk Talsma. Originally started October 1997, for distribution  
 * with the FlightGear project. Version 2 was written in August and 
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
@@ -26,40 +26,33 @@
 #include <string.h>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/fgpath.hxx>
 #include <Main/options.hxx>
 #include <Objects/texload.h>
 #ifdef __BORLANDC__
 #  define exception c_exception
 #endif
 #include <math.h>
-#include <FDM/flight.hxx>
+// #include <FDM/flight.hxx>
-#include "moon.hxx"
+#include "moonpos.hxx"
 /*************************************************************************
- * Moon::Moon(FGTime *t)
+ * MoonPos::MoonPos(double mjd)
- * Public constructor for class Moon. Initializes the orbital elements and 
+ * Public constructor for class MoonPos. Initializes the orbital elements and 
 * sets up the moon texture.
 * Argument: The current time.
- * the hard coded orbital elements for Moon are passed to 
+ * the hard coded orbital elements for MoonPos are passed to 
 * CelestialBody::CelestialBody();
 ************************************************************************/
-Moon::Moon(FGTime *t) :
+MoonPos::MoonPos(double mjd) :
  CelestialBody(125.1228, -0.0529538083,
 		5.1454,    0.00000,
 		318.0634,  0.1643573223,
 		60.266600, 0.000000,
 		0.054900,  0.000000,
-		115.3654,  13.0649929509, t)
+		115.3654,  13.0649929509, mjd)
 {
 }
-Moon::Moon() :
+MoonPos::MoonPos() :
  CelestialBody(125.1228, -0.0529538083,
 		5.1454,    0.00000,
 		318.0634,  0.1643573223,
@@ -70,18 +63,18 @@ Moon::Moon() :
 }
-Moon::~Moon()
+MoonPos::~MoonPos()
 {
 }
 /*****************************************************************************
- * void Moon::updatePosition(FGTime *t, Star *ourSun)
+ * void MoonPos::updatePosition(double mjd, Star *ourSun)
 * this member function calculates the actual topocentric position (i.e.) 
 * the position of the moon as seen from the current position on the surface
 * of the moon. 
 ****************************************************************************/
-void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
+void MoonPos::updatePosition(double mjd, double lst, double lat, Star *ourSun)
 {
  double 
    eccAnom, ecl, actTime,
@@ -89,19 +82,13 @@ void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
    Ls, Lm, D, F, mpar, gclat, rho, HA, g,
    geoRa, geoDec;
-  fgAIRCRAFT *air;
+  updateOrbElements(mjd);
-  FGInterface *f;
+  actTime = sgCalcActTime(mjd);
  air = &current_aircraft;
  f = air->fdm_state;
  updateOrbElements(t);
  actTime = fgCalcActTime(t);
  // calculate the angle between ecliptic and equatorial coordinate system
  // in Radians
-  ecl = ((DEG_TO_RAD * 23.4393) - (DEG_TO_RAD * 3.563E-7) * actTime);  
+  ecl = ((SGD_DEGREES_TO_RADIANS * 23.4393) - (SGD_DEGREES_TO_RADIANS * 3.563E-7) * actTime);  
-  eccAnom = fgCalcEccAnom(M, e);  // Calculate the eccentric anomaly
+  eccAnom = sgCalcEccAnom(M, e);  // Calculate the eccentric anomaly
  xv = a * (cos(eccAnom) - e);
  yv = a * (sqrt(1.0 - e*e) * sin(eccAnom));
  v = atan2(yv, xv);               // the moon's true anomaly
@@ -124,7 +111,7 @@ void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
  D = Lm - Ls;
  F = Lm - N;
-  lonEcl += DEG_TO_RAD * (-1.274 * sin (M - 2*D)
+  lonEcl += SGD_DEGREES_TO_RADIANS * (-1.274 * sin (M - 2*D)
 			  +0.658 * sin (2*D)
 			  -0.186 * sin(ourSun->getM())
 			  -0.059 * sin(2*M - 2*D)
@@ -137,7 +124,7 @@ void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
 			  -0.015 * sin(2*F - 2*D)
 			  +0.011 * sin(M - 4*D)
 			  );
-  latEcl += DEG_TO_RAD * (-0.173 * sin(F-2*D)
+  latEcl += SGD_DEGREES_TO_RADIANS * (-0.173 * sin(F-2*D)
 			  -0.055 * sin(M - F - 2*D)
 			  -0.046 * sin(M + F - 2*D)
 			  +0.033 * sin(F + 2*D)
@@ -146,7 +133,7 @@ void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
  r += (-0.58 * cos(M - 2*D)
 	-0.46 * cos(2*D)
 	);
-  // FG_LOG(FG_GENERAL, FG_INFO, "Running moon update");
+  // SG_LOG(SG_GENERAL, SG_INFO, "Running moon update");
  xg = r * cos(lonEcl) * cos(latEcl);
  yg = r * sin(lonEcl) * cos(latEcl);
  zg = r *               sin(latEcl);
@@ -158,9 +145,9 @@ void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
  geoRa  = atan2(ye, xe);
  geoDec = atan2(ze, sqrt(xe*xe + ye*ye));
-  /* FG_LOG( FG_GENERAL, FG_INFO, 
+  /* SG_LOG( SG_GENERAL, SG_INFO, 
-	  "(geocentric) geoRa = (" << (RAD_TO_DEG * geoRa) 
+	  "(geocentric) geoRa = (" << (SGD_RADIANS_TO_DEGREES * geoRa) 
-	  << "), geoDec= (" << (RAD_TO_DEG * geoDec) << ")" ); */
+	  << "), geoDec= (" << (SGD_RADIANS_TO_DEGREES * geoDec) << ")" ); */
  // Given the moon's geocentric ra and dec, calculate its 
@@ -170,30 +157,40 @@ void Moon::updatePosition(FGTime *t, double lat, Star *ourSun)
  // First calculate the moon's parrallax, that is, the apparent size of the 
  // (equatorial) radius of the earth, as seen from the moon 
  mpar = asin ( 1 / r);
-  // FG_LOG( FG_GENERAL, FG_INFO, "r = " << r << " mpar = " << mpar );
+  // SG_LOG( SG_GENERAL, SG_INFO, "r = " << r << " mpar = " << mpar );
-  // FG_LOG( FG_GENERAL, FG_INFO, "lat = " << f->get_Latitude() );
+  // SG_LOG( SG_GENERAL, SG_INFO, "lat = " << f->get_Latitude() );
  gclat = lat - 0.003358 * 
-      sin (2 * DEG_TO_RAD * lat );
+      sin (2 * SGD_DEGREES_TO_RADIANS * lat );
-  // FG_LOG( FG_GENERAL, FG_INFO, "gclat = " << gclat );
+  // SG_LOG( SG_GENERAL, SG_INFO, "gclat = " << gclat );
-  rho = 0.99883 + 0.00167 * cos(2 * DEG_TO_RAD * lat);
+  rho = 0.99883 + 0.00167 * cos(2 * SGD_DEGREES_TO_RADIANS * lat);
-  // FG_LOG( FG_GENERAL, FG_INFO, "rho = " << rho );
+  // SG_LOG( SG_GENERAL, SG_INFO, "rho = " << rho );
  if (geoRa < 0)
-    geoRa += (2*FG_PI);
+    geoRa += SGD_2PI;
-  HA = t->getLst() - (3.8197186 * geoRa);
+  HA = lst - (3.8197186 * geoRa);
-  /* FG_LOG( FG_GENERAL, FG_INFO, "t->getLst() = " << t->getLst() 
+  /* SG_LOG( SG_GENERAL, SG_INFO, "t->getLst() = " << t->getLst() 
 	  << " HA = " << HA ); */
  g = atan (tan(gclat) / cos ((HA / 3.8197186)));
-  // FG_LOG( FG_GENERAL, FG_INFO, "g = " << g );
+  // SG_LOG( SG_GENERAL, SG_INFO, "g = " << g );
  rightAscension = geoRa - mpar * rho * cos(gclat) * sin(HA) / cos (geoDec);
-  declination = geoDec - mpar * rho * sin (gclat) * sin (g - geoDec) / sin(g);
+  if (fabs(lat) > 0) {
      declination
 	  = geoDec - mpar * rho * sin (gclat) * sin (g - geoDec) / sin(g);
  } else {
      declination = geoDec;
      // cerr << "Geocentric vs. Topocentric position" << endl;
      // cerr << "RA (difference)  : "
      //      << SGD_RADIANS_TO_DEGREES * (geoRa - rightAscension) << endl;
      // cerr << "Dec (difference) : "
      //      << SGD_RADIANS_TO_DEGREES * (geoDec - declination) << endl;
  }
-  /* FG_LOG( FG_GENERAL, FG_INFO, 
+  /* SG_LOG( SG_GENERAL, SG_INFO, 
-	  "Ra = (" << (RAD_TO_DEG *rightAscension) 
+	  "Ra = (" << (SGD_RADIANS_TO_DEGREES *rightAscension) 
-	  << "), Dec= (" << (RAD_TO_DEG *declination) << ")" ); */
+	  << "), Dec= (" << (SGD_RADIANS_TO_DEGREES *declination) << ")" ); */
 }
@@ -1,40 +1,37 @@
 /**************************************************************************
- * moon.hxx
+ * moonpos.hxx
 * Written by Durk Talsma. Originally started October 1997, for distribution  
 * with the FlightGear project. Version 2 was written in August and 
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
-#ifndef _MOON_HXX_
+#ifndef _MOONPOS_HXX_
-#define _MOON_HXX_
+#define _MOONPOS_HXX_
 #include <simgear/constants.h>
-#include <Aircraft/aircraft.hxx>
+#include <simgear/ephemeris/celestialBody.hxx>
-#include <Main/views.hxx>
+#include <simgear/ephemeris/star.hxx>
 #include <Time/fg_time.hxx>
 #include "celestialBody.hxx"
 #include "star.hxx"
-class Moon : public CelestialBody
+class MoonPos : public CelestialBody
 {
 private:
@@ -52,12 +49,12 @@ private:
 public:
-    Moon( FGTime *t);
+    MoonPos(double mjd);
-    Moon();
+    MoonPos();
-    ~Moon();
+    ~MoonPos();
-    void updatePosition(FGTime *t, double lat, Star *ourSun);
+    void updatePosition(double mjd, double lst, double lat, Star *ourSun);
    // void newImage();
 };
-#endif // _MOON_HXX_
+#endif // _MOONPOS_HXX_
@@ -5,19 +5,19 @@
 * September 1998. This code is based upon algorithms and data kindly 
 * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
 *
- * This program is free software; you can redistribute it and/or
+ * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
+ * modify it under the terms of the GNU Library General Public
- * published by the Free Software Foundation; either version 2 of the
+ * License as published by the Free Software Foundation; either
- * License, or (at your option) any later version.
+ * 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
+ * This library is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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.
+ * Library 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * $Id$
 **************************************************************************/
@@ -30,19 +30,19 @@
 #include "neptune.hxx"
 /*************************************************************************
- * Neptune::Neptune(FGTime *t)
+ * Neptune::Neptune(double mjd)
 * Public constructor for class Neptune
 * Argument: The current time.
 * the hard coded orbital elements for Neptune are passed to 
 * CelestialBody::CelestialBody();
 ************************************************************************/
-Neptune::Neptune(FGTime *t) :
+Neptune::Neptune(double mjd) :
  CelestialBody(131.7806,   3.0173000E-5,
 		1.7700,	   -2.550E-7,
 		272.8461,  -6.027000E-6,	
 		30.058260,  3.313E-8,
 		0.008606,   2.150E-9,
-		260.2471,   0.00599514700, t)
+		260.2471,   0.00599514700, mjd)
 {
 }
 Neptune::Neptune() :
@@ -55,14 +55,14 @@ Neptune::Neptune() :
 {
 }
 /*************************************************************************
- * void Neptune::updatePosition(FGTime *t, Star *ourSun)
+ * void Neptune::updatePosition(double mjd, Star *ourSun)
 * 
 * calculates the current position of Neptune, by calling the base class,
 * CelestialBody::updatePosition(); The current magnitude is calculated using 
 * a Neptune specific equation
 *************************************************************************/
-void Neptune::updatePosition(FGTime *t, Star *ourSun)
+void Neptune::updatePosition(double mjd, Star *ourSun)
 {
-  CelestialBody::updatePosition(t, ourSun);
+  CelestialBody::updatePosition(mjd, ourSun);
  magnitude = -6.90 + 5*log10 (r*R) + 0.001 *FV;
 }
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1 @@`
							`03/25/2001 - Resolve location of Sky dome implimentation documentation.`
		`@@ -0,0 +1,3 @@`
							`SUBDIRS = $(MIPSpro_DIRS)`

							`DIST_SUBDIRS = MIPSpro721 MIPSpro740`
`@@ -8,4 +8,4 @@ include_HEADERS = debug_types.h logstream.hxx`

	`libsgdebug_a_SOURCES = logstream.cxx`	`libsgdebug_a_SOURCES = logstream.cxx`

	`INCLUDES += -I$(top_builddir)`	`INCLUDES = -I$(top_srcdir)`