New Version: 3.2.0

Using just 0 as prefix for octal number can lead to confusion
where numbers could be interpreted the wrong way (oct instead of
dec).
Lets follow the same convention as Python 3 and Ecma 262 level 6
and use '0o' as prefix which can not be confused inadvertently.

.cvsignore

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

.gitignore

@@ -0,0 +1,16 @@
+.*
+*~
+Makefile
+*.o
+lib*.a
+.*.swp
+cmake_install.cmake
+CMakeFiles
+CMakeCache.txt
+CPackConfig.cmake
+CPackSourceConfig.cmake
+cmake_uninstall.cmake
+CTestTestfile.cmake
+install_manifest.txt
+build*
+Build

3rdparty/CMakeLists.txt

@@ -0,0 +1,4 @@
+if (NOT SYSTEM_EXPAT)
+	add_subdirectory(expat)
+endif()
+

3rdparty/expat/CMakeLists.txt

@@ -0,0 +1,33 @@
+
+configure_file (
+    "${PROJECT_SOURCE_DIR}/3rdparty/expat/expat_config_cmake.in"
+    "${PROJECT_BINARY_DIR}/3rdparty/expat/expat_config.h"
+)
+
+set(expat_sources 
+	asciitab.h
+        hashtable.h
+        iasciitab.h
+        latin1tab.h
+        nametab.h
+        utf8tab.h
+        xmldef.h
+        xmlparse.h
+        xmlrole.h
+        xmltok.h
+        xmltok_impl.h
+        hashtable.c
+        xmlparse.c
+        xmlrole.c
+        xmltok.c
+        internal.h
+        ascii.h
+        sg_expat.h
+        sg_expat_external.h 
+	)
+
+foreach(s ${expat_sources})
+	set_property(GLOBAL
+		APPEND PROPERTY LOCAL_EXPAT_SOURCES 
+        "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+endforeach()

3rdparty/expat/Expat.COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+                               and Clark Cooper
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

3rdparty/expat/ascii.h

@@ -0,0 +1,92 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#define ASCII_A 0x41
+#define ASCII_B 0x42
+#define ASCII_C 0x43
+#define ASCII_D 0x44
+#define ASCII_E 0x45
+#define ASCII_F 0x46
+#define ASCII_G 0x47
+#define ASCII_H 0x48
+#define ASCII_I 0x49
+#define ASCII_J 0x4A
+#define ASCII_K 0x4B
+#define ASCII_L 0x4C
+#define ASCII_M 0x4D
+#define ASCII_N 0x4E
+#define ASCII_O 0x4F
+#define ASCII_P 0x50
+#define ASCII_Q 0x51
+#define ASCII_R 0x52
+#define ASCII_S 0x53
+#define ASCII_T 0x54
+#define ASCII_U 0x55
+#define ASCII_V 0x56
+#define ASCII_W 0x57
+#define ASCII_X 0x58
+#define ASCII_Y 0x59
+#define ASCII_Z 0x5A
+
+#define ASCII_a 0x61
+#define ASCII_b 0x62
+#define ASCII_c 0x63
+#define ASCII_d 0x64
+#define ASCII_e 0x65
+#define ASCII_f 0x66
+#define ASCII_g 0x67
+#define ASCII_h 0x68
+#define ASCII_i 0x69
+#define ASCII_j 0x6A
+#define ASCII_k 0x6B
+#define ASCII_l 0x6C
+#define ASCII_m 0x6D
+#define ASCII_n 0x6E
+#define ASCII_o 0x6F
+#define ASCII_p 0x70
+#define ASCII_q 0x71
+#define ASCII_r 0x72
+#define ASCII_s 0x73
+#define ASCII_t 0x74
+#define ASCII_u 0x75
+#define ASCII_v 0x76
+#define ASCII_w 0x77
+#define ASCII_x 0x78
+#define ASCII_y 0x79
+#define ASCII_z 0x7A
+
+#define ASCII_0 0x30
+#define ASCII_1 0x31
+#define ASCII_2 0x32
+#define ASCII_3 0x33
+#define ASCII_4 0x34
+#define ASCII_5 0x35
+#define ASCII_6 0x36
+#define ASCII_7 0x37
+#define ASCII_8 0x38
+#define ASCII_9 0x39
+
+#define ASCII_TAB 0x09
+#define ASCII_SPACE 0x20
+#define ASCII_EXCL 0x21
+#define ASCII_QUOT 0x22
+#define ASCII_AMP 0x26
+#define ASCII_APOS 0x27
+#define ASCII_MINUS 0x2D
+#define ASCII_PERIOD 0x2E
+#define ASCII_COLON 0x3A
+#define ASCII_SEMI 0x3B
+#define ASCII_LT 0x3C
+#define ASCII_EQUALS 0x3D
+#define ASCII_GT 0x3E
+#define ASCII_LSQB 0x5B
+#define ASCII_RSQB 0x5D
+#define ASCII_UNDERSCORE 0x5F
+#define ASCII_LPAREN 0x28
+#define ASCII_RPAREN 0x29
+#define ASCII_FF 0x0C
+#define ASCII_SLASH 0x2F
+#define ASCII_HASH 0x23
+#define ASCII_PIPE 0x7C
+#define ASCII_COMMA 0x2C

3rdparty/expat/expat_config_cmake.in

@@ -0,0 +1,41 @@
+
+#ifndef EXPAT_CONFIG_H
+#define EXPAT_CONFIG_H
+
+#cmakedefine HAVE_WINDOWS_H
+
+#ifdef HAVE_WINDOWS_H
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+    #undef WIN32_LEAN_AND_MEAN
+#endif
+
+/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
+#define BYTEORDER  1234
+
+/* Define to 1 if you have the `bcopy' function. */
+#cmakedefine HAVE_BCOPY
+
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE
+
+/* Define to 1 if you have a working `mmap' system call. */
+#cmakedefine HAVE_MMAP
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#cmakedefine HAVE_UNISTD_H
+
+/* whether byteorder is bigendian */
+#undef WORDS_BIGENDIAN
+
+/* Define to specify how much context to retain around the current parse
+   point. */
+#define XML_CONTEXT_BYTES 1024
+
+/* Define to make parameter entity parsing functionality available. */
+#define XML_DTD
+
+/* Define to make XML Namespaces functionality available. */
+#define XML_NS
+
+#endif /* ifndef EXPAT_CONFIG_H */

3rdparty/expat/internal.h

@@ -0,0 +1,73 @@
+/* internal.h
+
+   Internal definitions used by Expat.  This is not needed to compile
+   client code.
+
+   The following calling convention macros are defined for frequently
+   called functions:
+
+   FASTCALL    - Used for those internal functions that have a simple
+                 body and a low number of arguments and local variables.
+
+   PTRCALL     - Used for functions called though function pointers.
+
+   PTRFASTCALL - Like PTRCALL, but for low number of arguments.
+
+   inline      - Used for selected internal functions for which inlining
+                 may improve performance on some platforms.
+
+   Note: Use of these macros is based on judgement, not hard rules,
+         and therefore subject to change.
+*/
+
+#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
+/* We'll use this version by default only where we know it helps.
+
+   regparm() generates warnings on Solaris boxes.   See SF bug #692878.
+
+   Instability reported with egcs on a RedHat Linux 7.3.
+   Let's comment out:
+   #define FASTCALL __attribute__((stdcall, regparm(3)))
+   and let's try this:
+*/
+#define FASTCALL __attribute__((regparm(3)))
+#define PTRFASTCALL __attribute__((regparm(3)))
+#endif
+
+/* Using __fastcall seems to have an unexpected negative effect under
+   MS VC++, especially for function pointers, so we won't use it for
+   now on that platform. It may be reconsidered for a future release
+   if it can be made more effective.
+   Likely reason: __fastcall on Windows is like stdcall, therefore
+   the compiler cannot perform stack optimizations for call clusters.
+*/
+
+/* Make sure all of these are defined if they aren't already. */
+
+#ifndef FASTCALL
+#define FASTCALL
+#endif
+
+#ifndef PTRCALL
+#define PTRCALL
+#endif
+
+#ifndef PTRFASTCALL
+#define PTRFASTCALL
+#endif
+
+#ifndef XML_MIN_SIZE
+#if !defined(__cplusplus) && !defined(inline)
+#ifdef __GNUC__
+#define inline __inline
+#endif /* __GNUC__ */
+#endif
+#endif /* XML_MIN_SIZE */
+
+#ifdef __cplusplus
+#define inline inline
+#else
+#ifndef inline
+#define inline
+#endif
+#endif

3rdparty/expat/sg_expat_external.h

@@ -0,0 +1,115 @@
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#ifndef Expat_External_INCLUDED
+#define Expat_External_INCLUDED 1
+
+/* External API definitions */
+
+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
+#define XML_USE_MSC_EXTENSIONS 1
+#endif
+
+/* Expat tries very hard to make the API boundary very specifically
+   defined.  There are two macros defined to control this boundary;
+   each of these can be defined before including this header to
+   achieve some different behavior, but doing so it not recommended or
+   tested frequently.
+
+   XMLCALL    - The calling convention to use for all calls across the
+                "library boundary."  This will default to cdecl, and
+                try really hard to tell the compiler that's what we
+                want.
+
+   XMLIMPORT  - Whatever magic is needed to note that a function is
+                to be imported from a dynamically loaded library
+                (.dll, .so, or .sl, depending on your platform).
+
+   The XMLCALL macro was added in Expat 1.95.7.  The only one which is
+   expected to be directly useful in client code is XMLCALL.
+
+   Note that on at least some Unix versions, the Expat library must be
+   compiled with the cdecl calling convention as the default since
+   system headers may assume the cdecl convention.
+*/
+#ifndef XMLCALL
+#if defined(_MSC_VER)
+#define XMLCALL __cdecl
+#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
+#define XMLCALL __attribute__((cdecl))
+#else
+/* For any platform which uses this definition and supports more than
+   one calling convention, we need to extend this definition to
+   declare the convention used on that platform, if it's possible to
+   do so.
+
+   If this is the case for your platform, please file a bug report
+   with information on how to identify your platform via the C
+   pre-processor and how to specify the same calling convention as the
+   platform's malloc() implementation.
+*/
+#define XMLCALL
+#endif
+#endif  /* not defined XMLCALL */
+
+
+#if !defined(XML_STATIC) && !defined(XMLIMPORT)
+#ifndef XML_BUILDING_EXPAT
+/* using Expat from an application */
+
+#ifdef XML_USE_MSC_EXTENSIONS
+#define XMLIMPORT __declspec(dllimport)
+#endif
+
+#endif
+#endif  /* not defined XML_STATIC */
+
+
+/* If we didn't define it above, define it away: */
+#ifndef XMLIMPORT
+#define XMLIMPORT
+#endif
+
+
+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#define XML_UNICODE
+#endif
+
+#ifdef XML_UNICODE     /* Information is UTF-16 encoded. */
+#ifdef XML_UNICODE_WCHAR_T
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+#else
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+#endif /* XML_UNICODE_WCHAR_T */
+#else                  /* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+#endif /* XML_UNICODE */
+
+#ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */
+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
+typedef __int64 XML_Index; 
+typedef unsigned __int64 XML_Size;
+#else
+typedef long long XML_Index;
+typedef unsigned long long XML_Size;
+#endif
+#else
+typedef long XML_Index;
+typedef unsigned long XML_Size;
+#endif /* XML_LARGE_SIZE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_External_INCLUDED */

3rdparty/expat/xmldef.h

@@ -53,7 +53,7 @@ particular environments. */
 
 #ifdef MOZILLA
 
-#include "nspr.h"
+#include <nspr.h>
 #define malloc(x) PR_Malloc(x)
 #define realloc(x, y) PR_Realloc((x), (y))
 #define calloc(x, y) PR_Calloc((x),(y))

3rdparty/expat/xmlrole.h

@@ -1,36 +1,16 @@
-/*
-The contents of this file are subject to the Mozilla Public License
-Version 1.1 (the "License"); you may not use this file except in
-compliance with the License. You may obtain a copy of the License at
-http://www.mozilla.org/MPL/
-
-Software distributed under the License is distributed on an "AS IS"
-basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
-License for the specific language governing rights and limitations
-under the License.
-
-The Original Code is expat.
-
-The Initial Developer of the Original Code is James Clark.
-Portions created by James Clark are Copyright (C) 1998, 1999
-James Clark. All Rights Reserved.
-
-Contributor(s):
-
-Alternatively, the contents of this file may be used under the terms
-of the GNU General Public License (the "GPL"), in which case the
-provisions of the GPL are applicable instead of those above.  If you
-wish to allow use of your version of this file only under the terms of
-the GPL and not to allow others to use your version of this file under
-the MPL, indicate your decision by deleting the provisions above and
-replace them with the notice and other provisions required by the
-GPL. If you do not delete the provisions above, a recipient may use
-your version of this file under either the MPL or the GPL.
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
 */
 
 #ifndef XmlRole_INCLUDED
 #define XmlRole_INCLUDED 1
 
+#ifdef __VMS
+/*      0        1         2         3      0        1         2         3
+        1234567890123456789012345678901     1234567890123456789012345678901 */
+#define XmlPrologStateInitExternalEntity    XmlPrologStateInitExternalEnt
+#endif
+
 #include "xmltok.h"
 
 #ifdef __cplusplus
@@ -42,16 +22,21 @@ enum {
   XML_ROLE_NONE = 0,
   XML_ROLE_XML_DECL,
   XML_ROLE_INSTANCE_START,
+  XML_ROLE_DOCTYPE_NONE,
   XML_ROLE_DOCTYPE_NAME,
   XML_ROLE_DOCTYPE_SYSTEM_ID,
   XML_ROLE_DOCTYPE_PUBLIC_ID,
+  XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
   XML_ROLE_DOCTYPE_CLOSE,
   XML_ROLE_GENERAL_ENTITY_NAME,
   XML_ROLE_PARAM_ENTITY_NAME,
+  XML_ROLE_ENTITY_NONE,
   XML_ROLE_ENTITY_VALUE,
   XML_ROLE_ENTITY_SYSTEM_ID,
   XML_ROLE_ENTITY_PUBLIC_ID,
+  XML_ROLE_ENTITY_COMPLETE,
   XML_ROLE_ENTITY_NOTATION_NAME,
+  XML_ROLE_NOTATION_NONE,
   XML_ROLE_NOTATION_NAME,
   XML_ROLE_NOTATION_SYSTEM_ID,
   XML_ROLE_NOTATION_NO_SYSTEM_ID,
@@ -67,11 +52,13 @@ enum {
   XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
   XML_ROLE_ATTRIBUTE_ENUM_VALUE,
   XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
+  XML_ROLE_ATTLIST_NONE,
   XML_ROLE_ATTLIST_ELEMENT_NAME,
   XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
   XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
   XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
   XML_ROLE_FIXED_ATTRIBUTE_VALUE,
+  XML_ROLE_ELEMENT_NONE,
   XML_ROLE_ELEMENT_NAME,
   XML_ROLE_CONTENT_ANY,
   XML_ROLE_CONTENT_EMPTY,
@@ -87,19 +74,35 @@ enum {
   XML_ROLE_CONTENT_ELEMENT_REP,
   XML_ROLE_CONTENT_ELEMENT_OPT,
   XML_ROLE_CONTENT_ELEMENT_PLUS,
+  XML_ROLE_PI,
+  XML_ROLE_COMMENT,
+#ifdef XML_DTD
+  XML_ROLE_TEXT_DECL,
+  XML_ROLE_IGNORE_SECT,
+  XML_ROLE_INNER_PARAM_ENTITY_REF,
+#endif /* XML_DTD */
   XML_ROLE_PARAM_ENTITY_REF
 };
 
 typedef struct prolog_state {
-  int (*handler)(struct prolog_state *state,
-	         int tok,
-		 const char *ptr,
-		 const char *end,
-		 const ENCODING *enc);
+  int (PTRCALL *handler) (struct prolog_state *state,
+                          int tok,
+                          const char *ptr,
+                          const char *end,
+                          const ENCODING *enc);
   unsigned level;
+  int role_none;
+#ifdef XML_DTD
+  unsigned includeLevel;
+  int documentEntity;
+  int inEntityValue;
+#endif /* XML_DTD */
 } PROLOG_STATE;
 
-void XMLTOKAPI XmlPrologStateInit(PROLOG_STATE *);
+void XmlPrologStateInit(PROLOG_STATE *);
+#ifdef XML_DTD
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
+#endif /* XML_DTD */
 
 #define XmlTokenRole(state, tok, ptr, end, enc) \
  (((state)->handler)(state, tok, ptr, end, enc))

3rdparty/expat/xmltok.h

@@ -0,0 +1,316 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#ifndef XmlTok_INCLUDED
+#define XmlTok_INCLUDED 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The following token may be returned by XmlContentTok */
+#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be
+                                    start of illegal ]]> sequence */
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_NONE -4          /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR -3   /* A CR at the end of the scan;
+                                    might be part of CRLF sequence */
+#define XML_TOK_PARTIAL_CHAR -2  /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1       /* only part of a token */
+#define XML_TOK_INVALID 0
+
+/* The following tokens are returned by XmlContentTok; some are also
+   returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
+*/
+#define XML_TOK_START_TAG_WITH_ATTS 1
+#define XML_TOK_START_TAG_NO_ATTS 2
+#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
+#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
+#define XML_TOK_END_TAG 5
+#define XML_TOK_DATA_CHARS 6
+#define XML_TOK_DATA_NEWLINE 7
+#define XML_TOK_CDATA_SECT_OPEN 8
+#define XML_TOK_ENTITY_REF 9
+#define XML_TOK_CHAR_REF 10               /* numeric character reference */
+
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_PI 11                     /* processing instruction */
+#define XML_TOK_XML_DECL 12               /* XML decl or text decl */
+#define XML_TOK_COMMENT 13
+#define XML_TOK_BOM 14                    /* Byte order mark */
+
+/* The following tokens are returned only by XmlPrologTok */
+#define XML_TOK_PROLOG_S 15
+#define XML_TOK_DECL_OPEN 16              /* <!foo */
+#define XML_TOK_DECL_CLOSE 17             /* > */
+#define XML_TOK_NAME 18
+#define XML_TOK_NMTOKEN 19
+#define XML_TOK_POUND_NAME 20             /* #name */
+#define XML_TOK_OR 21                     /* | */
+#define XML_TOK_PERCENT 22
+#define XML_TOK_OPEN_PAREN 23
+#define XML_TOK_CLOSE_PAREN 24
+#define XML_TOK_OPEN_BRACKET 25
+#define XML_TOK_CLOSE_BRACKET 26
+#define XML_TOK_LITERAL 27
+#define XML_TOK_PARAM_ENTITY_REF 28
+#define XML_TOK_INSTANCE_START 29
+
+/* The following occur only in element type declarations */
+#define XML_TOK_NAME_QUESTION 30          /* name? */
+#define XML_TOK_NAME_ASTERISK 31          /* name* */
+#define XML_TOK_NAME_PLUS 32              /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33         /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34        /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35   /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36   /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37       /* )+ */
+#define XML_TOK_COMMA 38
+
+/* The following token is returned only by XmlAttributeValueTok */
+#define XML_TOK_ATTRIBUTE_VALUE_S 39
+
+/* The following token is returned only by XmlCdataSectionTok */
+#define XML_TOK_CDATA_SECT_CLOSE 40
+
+/* With namespace processing this is returned by XmlPrologTok for a
+   name with a colon.
+*/
+#define XML_TOK_PREFIXED_NAME 41
+
+#ifdef XML_DTD
+#define XML_TOK_IGNORE_SECT 42
+#endif /* XML_DTD */
+
+#ifdef XML_DTD
+#define XML_N_STATES 4
+#else /* not XML_DTD */
+#define XML_N_STATES 3
+#endif /* not XML_DTD */
+
+#define XML_PROLOG_STATE 0
+#define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
+#ifdef XML_DTD
+#define XML_IGNORE_SECTION_STATE 3
+#endif /* XML_DTD */
+
+#define XML_N_LITERAL_TYPES 2
+#define XML_ATTRIBUTE_VALUE_LITERAL 0
+#define XML_ENTITY_VALUE_LITERAL 1
+
+/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
+#define XML_UTF8_ENCODE_MAX 4
+/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
+#define XML_UTF16_ENCODE_MAX 2
+
+typedef struct position {
+  /* first line and first column are 0 not 1 */
+  XML_Size lineNumber;
+  XML_Size columnNumber;
+} POSITION;
+
+typedef struct {
+  const char *name;
+  const char *valuePtr;
+  const char *valueEnd;
+  char normalized;
+} ATTRIBUTE;
+
+struct encoding;
+typedef struct encoding ENCODING;
+
+typedef int (PTRCALL *SCANNER)(const ENCODING *,
+                               const char *,
+                               const char *,
+                               const char **);
+
+struct encoding {
+  SCANNER scanners[XML_N_STATES];
+  SCANNER literalScanners[XML_N_LITERAL_TYPES];
+  int (PTRCALL *sameName)(const ENCODING *,
+                          const char *,
+                          const char *);
+  int (PTRCALL *nameMatchesAscii)(const ENCODING *,
+                                  const char *,
+                                  const char *,
+                                  const char *);
+  int (PTRFASTCALL *nameLength)(const ENCODING *, const char *);
+  const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
+  int (PTRCALL *getAtts)(const ENCODING *enc,
+                         const char *ptr,
+                         int attsMax,
+                         ATTRIBUTE *atts);
+  int (PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
+  int (PTRCALL *predefinedEntityName)(const ENCODING *,
+                                      const char *,
+                                      const char *);
+  void (PTRCALL *updatePosition)(const ENCODING *,
+                                 const char *ptr,
+                                 const char *end,
+                                 POSITION *);
+  int (PTRCALL *isPublicId)(const ENCODING *enc,
+                            const char *ptr,
+                            const char *end,
+                            const char **badPtr);
+  void (PTRCALL *utf8Convert)(const ENCODING *enc,
+                              const char **fromP,
+                              const char *fromLim,
+                              char **toP,
+                              const char *toLim);
+  void (PTRCALL *utf16Convert)(const ENCODING *enc,
+                               const char **fromP,
+                               const char *fromLim,
+                               unsigned short **toP,
+                               const unsigned short *toLim);
+  int minBytesPerChar;
+  char isUtf8;
+  char isUtf16;
+};
+
+/* Scan the string starting at ptr until the end of the next complete
+   token, but do not scan past eptr.  Return an integer giving the
+   type of token.
+
+   Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
+
+   Return XML_TOK_PARTIAL when the string does not contain a complete
+   token; nextTokPtr will not be set.
+
+   Return XML_TOK_INVALID when the string does not start a valid
+   token; nextTokPtr will be set to point to the character which made
+   the token invalid.
+
+   Otherwise the string starts with a valid token; nextTokPtr will be
+   set to point to the character following the end of that token.
+
+   Each data character counts as a single token, but adjacent data
+   characters may be returned together.  Similarly for characters in
+   the prolog outside literals, comments and processing instructions.
+*/
+
+
+#define XmlTok(enc, state, ptr, end, nextTokPtr) \
+  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
+
+#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+
+#define XmlContentTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+
+#ifdef XML_DTD
+
+#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+
+#endif /* XML_DTD */
+
+/* This is used for performing a 2nd-level tokenization on the content
+   of a literal that has already been returned by XmlTok.
+*/
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
+  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
+
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2))
+
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
+  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
+
+#define XmlNameLength(enc, ptr) \
+  (((enc)->nameLength)(enc, ptr))
+
+#define XmlSkipS(enc, ptr) \
+  (((enc)->skipS)(enc, ptr))
+
+#define XmlGetAttributes(enc, ptr, attsMax, atts) \
+  (((enc)->getAtts)(enc, ptr, attsMax, atts))
+
+#define XmlCharRefNumber(enc, ptr) \
+  (((enc)->charRefNumber)(enc, ptr))
+
+#define XmlPredefinedEntityName(enc, ptr, end) \
+  (((enc)->predefinedEntityName)(enc, ptr, end))
+
+#define XmlUpdatePosition(enc, ptr, end, pos) \
+  (((enc)->updatePosition)(enc, ptr, end, pos))
+
+#define XmlIsPublicId(enc, ptr, end, badPtr) \
+  (((enc)->isPublicId)(enc, ptr, end, badPtr))
+
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
+
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
+
+typedef struct {
+  ENCODING initEnc;
+  const ENCODING **encPtr;
+} INIT_ENCODING;
+
+int XmlParseXmlDecl(int isGeneralTextEntity,
+                    const ENCODING *enc,
+                    const char *ptr,
+                    const char *end,
+                    const char **badPtr,
+                    const char **versionPtr,
+                    const char **versionEndPtr,
+                    const char **encodingNamePtr,
+                    const ENCODING **namedEncodingPtr,
+                    int *standalonePtr);
+
+int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING *XmlGetUtf8InternalEncoding(void);
+const ENCODING *XmlGetUtf16InternalEncoding(void);
+int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
+int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
+int XmlSizeOfUnknownEncoding(void);
+
+
+typedef int (XMLCALL *CONVERTER) (void *userData, const char *p);
+
+ENCODING *
+XmlInitUnknownEncoding(void *mem,
+                       int *table,
+                       CONVERTER convert,
+                       void *userData);
+
+int XmlParseXmlDeclNS(int isGeneralTextEntity,
+                      const ENCODING *enc,
+                      const char *ptr,
+                      const char *end,
+                      const char **badPtr,
+                      const char **versionPtr,
+                      const char **versionEndPtr,
+                      const char **encodingNamePtr,
+                      const ENCODING **namedEncodingPtr,
+                      int *standalonePtr);
+
+int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING *XmlGetUtf8InternalEncodingNS(void);
+const ENCODING *XmlGetUtf16InternalEncodingNS(void);
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem,
+                         int *table,
+                         CONVERTER convert,
+                         void *userData);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlTok_INCLUDED */

3rdparty/expat/xmltok_ns.c

@@ -0,0 +1,115 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+/* This file is included! */
+#ifdef XML_TOK_NS_C
+
+const ENCODING *
+NS(XmlGetUtf8InternalEncoding)(void)
+{
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *
+NS(XmlGetUtf16InternalEncoding)(void)
+{
+#if BYTEORDER == 1234
+  return &ns(internal_little2_encoding).enc;
+#elif BYTEORDER == 4321
+  return &ns(internal_big2_encoding).enc;
+#else
+  const short n = 1;
+  return (*(const char *)&n
+          ? &ns(internal_little2_encoding).enc
+          : &ns(internal_big2_encoding).enc);
+#endif
+}
+
+static const ENCODING * const NS(encodings)[] = {
+  &ns(latin1_encoding).enc,
+  &ns(ascii_encoding).enc,
+  &ns(utf8_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(little2_encoding).enc,
+  &ns(utf8_encoding).enc /* NO_ENC */
+};
+
+static int PTRCALL
+NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
+                  XML_PROLOG_STATE, ptr, end, nextTokPtr);
+}
+
+static int PTRCALL
+NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
+                  XML_CONTENT_STATE, ptr, end, nextTokPtr);
+}
+
+int
+NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
+                    const char *name)
+{
+  int i = getEncodingIndex(name);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  SET_INIT_ENC_INDEX(p, i);
+  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
+  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
+  p->initEnc.updatePosition = initUpdatePosition;
+  p->encPtr = encPtr;
+  *encPtr = &(p->initEnc);
+  return 1;
+}
+
+static const ENCODING *
+NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
+{
+#define ENCODING_MAX 128
+  char buf[ENCODING_MAX];
+  char *p = buf;
+  int i;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
+  if (ptr != end)
+    return 0;
+  *p = 0;
+  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
+    return enc;
+  i = getEncodingIndex(buf);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  return NS(encodings)[i];
+}
+
+int
+NS(XmlParseXmlDecl)(int isGeneralTextEntity,
+                    const ENCODING *enc,
+                    const char *ptr,
+                    const char *end,
+                    const char **badPtr,
+                    const char **versionPtr,
+                    const char **versionEndPtr,
+                    const char **encodingName,
+                    const ENCODING **encoding,
+                    int *standalone)
+{
+  return doParseXmlDecl(NS(findEncoding),
+                        isGeneralTextEntity,
+                        enc,
+                        ptr,
+                        end,
+                        badPtr,
+                        versionPtr,
+                        versionEndPtr,
+                        encodingName,
+                        encoding,
+                        standalone);
+}
+
+#endif /* XML_TOK_NS_C */

CMakeLists.txt

@@ -0,0 +1,401 @@
+cmake_minimum_required (VERSION 2.6.4)
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckCXXSourceCompiles)
+include (CheckCXXCompilerFlag)
+
+project(SimGear)
+
+# read 'version' file into a variable (stripping any newlines or spaces)
+file(READ version versionFile)
+string(STRIP ${versionFile} SIMGEAR_VERSION)
+
+set(FIND_LIBRARY_USE_LIB64_PATHS ON)
+
+# use simgear version also as the SO version (if building SOs)
+SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})
+
+# Warning when build is not an out-of-source build.
+string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" InSourceBuild)
+if(InSourceBuild)
+    message(WARNING  "Avoid building inside the source tree!")
+    message(WARNING  "Create a separate build directory instead (i.e. 'sgbuild') and call CMake from there: ")
+    message(WARNING  "  mkdir ../sgbuild && cd ../sgbuild && cmake ${CMAKE_SOURCE_DIR}")
+endif(InSourceBuild)
+
+#packaging
+SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
+SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
+SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
+SET(CPACK_GENERATOR "TBZ2")
+SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
+
+
+# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+
+message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_SOURCE_GENERATOR TBZ2)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
+set(CPACK_SOURCE_IGNORE_FILES
+  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+
+message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
+
+include (CPack)
+
+# We have some custom .cmake scripts not in the official distribution.
+set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")
+
+# Change the default build type to something fast
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING
+      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
+      FORCE)
+endif(NOT CMAKE_BUILD_TYPE)
+
+# Determine name of library installation directory, i.e. "lib" vs "lib64", which
+# differs between all Debian-based vs all other Linux distros.
+# See cmake bug #11964, http://cmake.org/gitweb?p=cmake.git;a=commit;h=126c993d
+# GNUInstallDirs requires CMake >= 2.8.5, use own file for older cmake
+if(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+  include(GNUInstallDirs)
+else(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+  include(OldGNUInstallDirs)
+endif(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+message(STATUS "Library installation directory: ${CMAKE_INSTALL_LIBDIR}")
+
+#####################################################################################
+# Configure library search paths
+#####################################################################################
+
+if(NOT "${CMAKE_LIBRARY_ARCHITECTURE}" STREQUAL "")
+    # Workaround for Ubuntu/Debian which introduced the "multiarch" library
+    # directory structure, which is unsupported by CMake < 2.8.10, so we need to
+    # add paths manually
+    # see http://www.cmake.org/Bug/view.php?id=12049 and
+    # http://www.cmake.org/Bug/view.php?id=12037
+    list(APPEND ADDITIONAL_LIBRARY_PATHS
+         /usr/local/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+         /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+         /lib/${CMAKE_LIBRARY_ARCHITECTURE})
+    message(STATUS "additional library directories: ${ADDITIONAL_LIBRARY_PATHS}")
+endif()
+
+#####################################################################################
+
+if (NOT MSVC)
+option(SIMGEAR_SHARED   "Set to ON to build SimGear as a shared library/framework" OFF)
+option(SYSTEM_EXPAT     "Set to ON to build SimGear using the system libExpat" OFF)
+else()
+# Building SimGear DLLs is currently not supported for MSVC.
+set(SIMGEAR_SHARED OFF)
+# Using a system expat is currently not supported for MSVC - it would require shared simgear (DLL).
+set(SYSTEM_EXPAT OFF)
+endif()
+
+option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
+option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
+option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
+option(ENABLE_SOUND     "Set to OFF to disable building SimGear's sound support" ON)
+option(ENABLE_PKGUTIL   "Set to ON to build the sg_pkgutil application (default)" ON)
+
+if (MSVC)
+  GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_BINARY_DIR} PATH)
+  if (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty.x64")
+  else (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty")
+  endif (CMAKE_CL_64)
+  if (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT ${PARENT_DIR} CACHE PATH "Location where the third-party dependencies are extracted")
+  else (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+  endif (EXISTS ${TEST_3RDPARTY_DIR})
+else (MSVC)
+  set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+endif (MSVC)
+
+if (MSVC AND MSVC_3RDPARTY_ROOT)
+  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+  set( OSG_MSVC "msvc" )
+  if (${MSVC_VERSION} EQUAL 1700)
+      set( OSG_MSVC ${OSG_MSVC}110 )
+  elseif (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}100 )
+  else (${MSVC_VERSION} EQUAL 1700)
+      set( OSG_MSVC ${OSG_MSVC}90 )
+  endif (${MSVC_VERSION} EQUAL 1700)
+  if (CMAKE_CL_64)
+      set( OSG_MSVC ${OSG_MSVC}-64 )
+      set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
+  else (CMAKE_CL_64)
+      set( MSVC_3RDPARTY_DIR 3rdParty )
+  endif (CMAKE_CL_64)
+
+  set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenRTI/lib )
+  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenRTI/include)
+  find_path(BOOST_ROOT boost/version.hpp
+			${MSVC_3RDPARTY_ROOT}/boost
+			${MSVC_3RDPARTY_ROOT}/boost_1_52_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_51_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_50_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_49_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_48_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_47_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_46_1
+			${MSVC_3RDPARTY_ROOT}/boost_1_46_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_45_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_44_0
+			)
+  # set (BOOST_ROOT ${MSVC_3RDPARTY_ROOT}/boost_1_44_0)
+  message(STATUS "BOOST_ROOT is ${BOOST_ROOT}")
+  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
+endif (MSVC AND MSVC_3RDPARTY_ROOT)
+
+if(APPLE)
+  find_library(COCOA_LIBRARY Cocoa)
+endif()
+
+# Somehow this only works if included before searching for Boost...
+include(BoostTestTargets)
+
+find_package(Boost REQUIRED)
+set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
+
+if(SIMGEAR_HEADLESS)
+    message(STATUS "SimGear mode: HEADLESS")
+    set(ENABLE_SOUND 0)
+else()
+    message(STATUS "SimGear mode: NORMAL")
+    find_package(OpenGL REQUIRED)
+    
+    if (ENABLE_SOUND)
+        find_package(OpenAL REQUIRED)
+        message(STATUS "Sound support: ENABLED")
+    endif(ENABLE_SOUND)
+    
+    find_package(OpenSceneGraph 3.2.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgUtil)
+endif(SIMGEAR_HEADLESS)
+
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
+
+if (SYSTEM_EXPAT)
+    message(STATUS "Requested to use system Expat library, forcing SIMGEAR_SHARED to true")
+    set(SIMGEAR_SHARED ON)
+    find_package(EXPAT REQUIRED)
+
+else()
+    message(STATUS "Using built-in expat code")
+    # XML_STATIC is important to avoid sg_expat_external.h
+    # declaring symbols as declspec(import)
+    add_definitions(-DHAVE_EXPAT_CONFIG_H -DXML_STATIC)
+    set(EXPAT_INCLUDE_DIRS 
+	    ${PROJECT_SOURCE_DIR}/3rdparty/expat 
+	    ${PROJECT_BINARY_DIR}/3rdparty/expat)
+endif(SYSTEM_EXPAT)
+
+include_directories(${EXPAT_INCLUDE_DIRS})
+
+check_include_file(inttypes.h HAVE_INTTYPES_H)
+check_include_file(sys/time.h HAVE_SYS_TIME_H)
+check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H)
+check_include_file(unistd.h HAVE_UNISTD_H)
+check_include_file(windows.h HAVE_WINDOWS_H)
+
+if(HAVE_INTTYPES_H)
+  # ShivaVG needs inttypes.h
+  add_definitions(-DHAVE_INTTYPES_H)
+endif()
+
+if(ENABLE_RTI)
+    # See if we have any rti library variant installed
+    message(STATUS "RTI: ENABLED")
+    find_package(RTI)
+else()
+    message(STATUS "RTI: DISABLED")
+endif(ENABLE_RTI)
+
+check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+check_function_exists(ftime HAVE_FTIME)
+check_function_exists(timegm HAVE_TIMEGM)
+check_function_exists(rint HAVE_RINT)
+check_function_exists(mkdtemp HAVE_MKDTEMP)
+check_function_exists(bcopy HAVE_BCOPY)
+check_function_exists(mmap HAVE_MMAP)
+
+if(HAVE_UNISTD_H)
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "#include <unistd.h>
+        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
+            #error clock_gettime is not supported
+        #endif
+
+        int main() { return 0; }
+        "
+        HAVE_CLOCK_GETTIME)
+endif(HAVE_UNISTD_H)
+
+set(RT_LIBRARY "")
+if(HAVE_CLOCK_GETTIME)
+    check_library_exists(rt clock_gettime "" HAVE_RT)
+    if(HAVE_RT)
+        set(RT_LIBRARY rt)
+    endif(HAVE_RT)
+endif(HAVE_CLOCK_GETTIME)
+
+set(DL_LIBRARY "")
+check_cxx_source_compiles(
+    "#include <dlfcn.h>
+    int main(void) {
+        return 0;
+    }
+    "
+    HAVE_DLFCN_H)
+
+if(HAVE_DLFCN_H)
+    check_library_exists(dl dlerror "" HAVE_DL)
+    if(HAVE_DL)
+        set(DL_LIBRARY "dl")
+    endif()
+endif()
+
+SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
+SET(CMAKE_RELEASE_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_RELWITHDEBINFO_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_MINSIZEREL_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
+
+# isnan might not be real symbol, so can't check using function_exists
+check_cxx_source_compiles(
+    "#include <cmath> 
+    void f() { isnan(0.0);} "
+    HAVE_ISNAN)
+
+check_cxx_source_compiles(
+    "#include <cmath> 
+    void f() { std::isnan(0.0);} "
+    HAVE_STD_ISNAN)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    set(WARNING_FLAGS_CXX "-Wall")
+    set(WARNING_FLAGS_C   "-Wall")
+
+    # certain GCC versions don't provide the atomic builds, and hence
+    # require is to provide them in SGAtomic.cxx
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "int main() { unsigned mValue; return __sync_add_and_fetch(&mValue, 1); }"
+        GCC_ATOMIC_BUILTINS_FOUND)
+endif(CMAKE_COMPILER_IS_GNUCXX)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+   set(WARNING_FLAGS_CXX "-Wall -Wno-overloaded-virtual")
+   set(WARNING_FLAGS_C   "-Wall")
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+# boost goes haywire wrt static asserts
+    check_cxx_compiler_flag(-Wno-unused-local-typedefs HAS_NOWARN_UNUSED_TYPEDEFS)
+    if(HAS_NOWARN_UNUSED_TYPEDEFS)
+        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-unused-local-typedefs")
+    endif()
+endif()
+
+if(WIN32)
+
+    if(MINGW)
+        add_definitions(-D_WIN32_WINNT=0x501)
+    endif()
+
+    if(MSVC)
+        # turn off various warnings
+        # foreach(warning 4244 4251 4267 4275 4290 4786 4305 4996)
+        #     SET(WARNING_FLAGS "${WARNING_FLAGS} /wd${warning}")
+        # endforeach(warning)
+        
+        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /wd4996 /wd4250 -Dstrdup=_strdup")
+        if (${MSVC_VERSION} GREATER 1599)
+            set( MSVC_LD_FLAGS "/FORCE:MULTIPLE" )
+        endif (${MSVC_VERSION} GREATER 1599)
+    endif(MSVC)
+    
+    # assumed on Windows
+    set(HAVE_GETLOCALTIME 1)
+    
+    set( WINSOCK_LIBRARY "ws2_32.lib" )
+    set( RT_LIBRARY "winmm" )
+endif(WIN32)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")
+
+# use BEFORE to ensure local directories are used first, 
+# ahead of system-installed libs
+include_directories(BEFORE ${PROJECT_SOURCE_DIR})
+include_directories(BEFORE ${PROJECT_SOURCE_DIR}/simgear/canvas/ShivaVG/include)
+include_directories(BEFORE ${PROJECT_BINARY_DIR}/simgear)
+
+include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
+    ${Boost_INCLUDE_DIRS} 
+    ${ZLIB_INCLUDE_DIR} 
+    ${OPENAL_INCLUDE_DIR}
+)
+
+add_definitions(-DHAVE_CONFIG_H)
+
+# configure a header file to pass some of the CMake settings
+# to the source code
+configure_file (
+  "${PROJECT_SOURCE_DIR}/simgear/simgear_config_cmake.h.in"
+  "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
+  )
+
+if(ENABLE_TESTS)
+    # enable CTest / make test target
+    message(STATUS "Tests: ENABLED")
+
+    include (Dart)
+    enable_testing()
+else()
+    message(STATUS "Tests: DISABLED")
+endif(ENABLE_TESTS)
+
+# always set TEST_LIBS as it is also used by other tools/applications
+set(TEST_LIBS_INTERNAL_CORE
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${ZLIB_LIBRARY}
+    ${WINSOCK_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${COCOA_LIBRARY})
+set(TEST_LIBS SimGearCore ${TEST_LIBS_INTERNAL_CORE})
+
+if(NOT SIMGEAR_HEADLESS)
+    set(TEST_LIBS SimGearScene ${OPENGL_LIBRARIES} ${TEST_LIBS})
+endif()
+
+install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
+
+add_subdirectory(3rdparty)
+add_subdirectory(simgear)
+
+#-----------------------------------------------------------------------------
+### uninstall target
+#-----------------------------------------------------------------------------
+CONFIGURE_FILE(
+  "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/cmake_uninstall.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+  IMMEDIATE @ONLY)
+ADD_CUSTOM_TARGET(uninstall
+  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+  
+

CMakeModules/BoostTestTargets.cmake

@@ -0,0 +1,256 @@
+# - Add tests using boost::test
+#
+# Add this line to your test files in place of including a basic boost test header:
+#  #include <BoostTestTargetConfig.h>
+#
+# If you cannot do that and must use the included form for a given test,
+# include the line
+#  // OVERRIDE_BOOST_TEST_INCLUDED_WARNING
+# in the same file with the boost test include.
+#
+#  include(BoostTestTargets)
+#  add_boost_test(<testdriver_name> SOURCES <source1> [<more sources...>]
+#   [FAIL_REGULAR_EXPRESSION <additional fail regex>]
+#   [LAUNCHER <generic launcher script>]
+#   [LIBRARIES <library> [<library>...]]
+#   [RESOURCES <resource> [<resource>...]]
+#   [TESTS <testcasename> [<testcasename>...]])
+#
+#  If for some reason you need access to the executable target created,
+#  it can be found in ${${testdriver_name}_TARGET_NAME} as specified when
+#  you called add_boost_test
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Requires:
+# 	GetForceIncludeDefinitions
+# 	CopyResourcesToBuildTree
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__add_boost_test)
+	return()
+endif()
+set(__add_boost_test YES)
+
+set(BOOST_TEST_TARGET_PREFIX "test")
+
+if(NOT Boost_FOUND)
+	find_package(Boost 1.34.0 QUIET)
+endif()
+if("${Boost_VERSION}0" LESS "1034000")
+	set(_shared_msg
+		"NOTE: boost::test-based targets and tests cannot "
+		"be added: boost >= 1.34.0 required but not found. "
+		"(found: '${Boost_VERSION}'; want >=103400) ")
+	if(BUILD_TESTING)
+		message(FATAL_ERROR
+			${_shared_msg}
+			"You may disable BUILD_TESTING to continue without the "
+			"tests.")
+	else()
+		message(STATUS
+			${_shared_msg}
+			"BUILD_TESTING disabled, so continuing anyway.")
+	endif()
+endif()
+
+include(GetForceIncludeDefinitions)
+include(CopyResourcesToBuildTree)
+
+if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
+	set(_boosttesttargets_libs)
+	set(_boostConfig "BoostTestTargetsIncluded.h")
+	if(NOT Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
+		find_package(Boost 1.34.0 QUIET COMPONENTS unit_test_framework)
+	endif()
+	if(Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
+		set(_boosttesttargets_libs "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}")
+		if(Boost_USE_STATIC_LIBS)
+			set(_boostConfig "BoostTestTargetsStatic.h")
+		else()
+			set(_boostConfig "BoostTestTargetsDynamic.h")
+		endif()
+	endif()
+	get_filename_component(_moddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+	configure_file("${_moddir}/${_boostConfig}"
+		"${CMAKE_CURRENT_BINARY_DIR}/BoostTestTargetConfig.h"
+		COPYONLY)
+	include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+endif()
+
+function(add_boost_test _name)
+	if(NOT BUILD_TESTING)
+		return()
+	endif()
+
+	# parse arguments
+	set(_nowhere)
+	set(_curdest _nowhere)
+	set(_val_args
+		SOURCES
+		FAIL_REGULAR_EXPRESSION
+		LAUNCHER
+		LIBRARIES
+		RESOURCES
+		TESTS)
+	set(_bool_args
+		USE_COMPILED_LIBRARY)
+	foreach(_arg ${_val_args} ${_bool_args})
+		set(${_arg})
+	endforeach()
+	foreach(_element ${ARGN})
+		list(FIND _val_args "${_element}" _val_arg_find)
+		list(FIND _bool_args "${_element}" _bool_arg_find)
+		if("${_val_arg_find}" GREATER "-1")
+			set(_curdest "${_element}")
+		elseif("${_bool_arg_find}" GREATER "-1")
+			set("${_element}" ON)
+			set(_curdest _nowhere)
+		else()
+			list(APPEND ${_curdest} "${_element}")
+		endif()
+	endforeach()
+
+	if(_nowhere)
+		message(FATAL_ERROR "Syntax error in use of add_boost_test!")
+	endif()
+
+	if(NOT SOURCES)
+		message(FATAL_ERROR
+			"Syntax error in use of add_boost_test: at least one source file required!")
+	endif()
+
+	if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
+
+		include_directories(${Boost_INCLUDE_DIRS})
+
+		set(includeType)
+		foreach(src ${SOURCES})
+			file(READ ${src} thefile)
+			if("${thefile}" MATCHES ".*BoostTestTargetConfig.h.*")
+				set(includeType CONFIGURED)
+				set(includeFileLoc ${src})
+				break()
+			elseif("${thefile}" MATCHES ".*boost/test/included/unit_test.hpp.*")
+				set(includeType INCLUDED)
+				set(includeFileLoc ${src})
+				set(_boosttesttargets_libs)	# clear this out - linking would be a bad idea
+				if(NOT
+					"${thefile}"
+					MATCHES
+					".*OVERRIDE_BOOST_TEST_INCLUDED_WARNING.*")
+					message("Please replace the include line in ${src} with this alternate include line instead:")
+					message("  \#include <BoostTestTargetConfig.h>")
+					message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
+				endif()
+				break()
+			endif()
+		endforeach()
+
+		if(NOT _boostTestTargetsNagged${_name} STREQUAL "${includeType}")
+			if("includeType" STREQUAL "CONFIGURED")
+				message(STATUS
+					"Test '${_name}' uses the CMake-configurable form of the boost test framework - congrats! (Including File: ${includeFileLoc})")
+			elseif("${includeType}" STREQUAL "INCLUDED")
+				message("In test '${_name}': ${includeFileLoc} uses the 'included' form of the boost unit test framework.")
+			else()
+				message("In test '${_name}': Didn't detect the CMake-configurable boost test include.")
+				message("Please replace your existing boost test include in that test with the following:")
+				message("  \#include <BoostTestTargetConfig.h>")
+				message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
+			endif()
+		endif()
+		set(_boostTestTargetsNagged${_name}
+			"${includeType}"
+			CACHE
+			INTERNAL
+			""
+			FORCE)
+
+
+		if(RESOURCES)
+			list(APPEND SOURCES ${RESOURCES})
+		endif()
+
+		# Generate a unique target name, using the relative binary dir
+		# and provided name. (transform all / into _ and remove all other
+		# non-alphabet characters)
+		file(RELATIVE_PATH
+			targetpath
+			"${CMAKE_BINARY_DIR}"
+			"${CMAKE_CURRENT_BINARY_DIR}")
+		string(REGEX REPLACE "[^A-Za-z/_]" "" targetpath "${targetpath}")
+		string(REPLACE "/" "_" targetpath "${targetpath}")
+
+		set(_target_name ${BOOST_TEST_TARGET_PREFIX}-${targetpath}-${_name})
+		set(${_name}_TARGET_NAME "${_target_name}" PARENT_SCOPE)
+
+		# Build the test.
+		add_executable(${_target_name} ${SOURCES})
+
+		list(APPEND LIBRARIES ${_boosttesttargets_libs})
+
+		if(LIBRARIES)
+			target_link_libraries(${_target_name} ${LIBRARIES})
+		endif()
+
+		if(RESOURCES)
+			set_property(TARGET ${_target_name} PROPERTY RESOURCE ${RESOURCES})
+			copy_resources_to_build_tree(${_target_name})
+		endif()
+
+		if(NOT Boost_TEST_FLAGS)
+#			set(Boost_TEST_FLAGS --catch_system_error=yes --output_format=XML)
+			set(Boost_TEST_FLAGS --catch_system_error=yes)
+		endif()
+
+		# TODO: Figure out why only recent boost handles individual test running properly
+
+		if(LAUNCHER)
+			set(_test_command ${LAUNCHER} "\$<TARGET_FILE:${_target_name}>")
+		else()
+			set(_test_command ${_target_name})
+		endif()
+
+		if(TESTS AND ( "${Boost_VERSION}" VERSION_GREATER "103799" ))
+			foreach(_test ${TESTS})
+				add_test(
+					${_name}-${_test}
+					${_test_command} --run_test=${_test} ${Boost_TEST_FLAGS}
+				)
+				if(FAIL_REGULAR_EXPRESSION)
+					set_tests_properties(${_name}-${_test}
+						PROPERTIES
+						FAIL_REGULAR_EXPRESSION
+						"${FAIL_REGULAR_EXPRESSION}")
+				endif()
+			endforeach()
+		else()
+			add_test(
+				${_name}-boost_test
+				${_test_command} ${Boost_TEST_FLAGS}
+			)
+			if(FAIL_REGULAR_EXPRESSION)
+				set_tests_properties(${_name}-boost_test
+					PROPERTIES
+					FAIL_REGULAR_EXPRESSION
+					"${FAIL_REGULAR_EXPRESSION}")
+			endif()
+		endif()
+
+		# CppCheck the test if we can.
+		if(COMMAND add_cppcheck)
+			add_cppcheck(${_target_name} STYLE UNUSED_FUNCTIONS)
+		endif()
+
+	endif()
+endfunction()

CMakeModules/BoostTestTargetsDynamic.h

@@ -0,0 +1,8 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF dynamic library
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>

CMakeModules/BoostTestTargetsIncluded.h

@@ -0,0 +1,7 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF included framework
+
+#include <boost/test/included/unit_test.hpp>

CMakeModules/BoostTestTargetsStatic.h

@@ -0,0 +1,7 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF static library
+
+#include <boost/test/unit_test.hpp>

CMakeModules/CopyResourcesToBuildTree.cmake

@@ -0,0 +1,83 @@
+# - Copy the resources your app needs to the build tree.
+#
+#  copy_resources_to_build_tree(<target_name>)
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__copy_resources_to_build_tree)
+	return()
+endif()
+set(__copy_resources_to_build_tree YES)
+
+function(copy_resources_to_build_tree _target)
+	get_target_property(_resources ${_target} RESOURCE)
+	if(NOT _resources)
+		# Bail if no resources
+		message(STATUS
+			"Told to copy resources for target ${_target}, but "
+			"no resources are set!")
+		return()
+	endif()
+
+	get_target_property(_path ${_target} LOCATION)
+	get_filename_component(_path "${_path}" PATH)
+
+	if(NOT MSVC AND NOT "${CMAKE_GENERATOR}" MATCHES "Makefiles")
+		foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+			get_target_property(_path${_config} ${_target} LOCATION_${_config})
+			get_filename_component(_path${_config} "${_path${_config}}" PATH)
+			add_custom_command(TARGET ${_target}
+						POST_BUILD
+						COMMAND
+						${CMAKE_COMMAND}
+						ARGS -E make_directory "${_path${_config}}/"
+						COMMENT "Creating directory ${_path${_config}}/")
+		endforeach()
+	endif()
+
+	foreach(_res ${_resources})
+		if(NOT IS_ABSOLUTE "${_res}")
+			get_filename_component(_res "${_res}" ABSOLUTE)
+		endif()
+		get_filename_component(_name "${_res}" NAME)
+
+		if(MSVC)
+			# Working dir is solution file dir, not exe file dir.
+			add_custom_command(TARGET ${_target}
+				POST_BUILD
+				COMMAND
+				${CMAKE_COMMAND}
+				ARGS -E copy "${_res}" "${CMAKE_BINARY_DIR}/"
+				COMMENT "Copying ${_name} to ${CMAKE_BINARY_DIR}/ for MSVC")
+		else()
+			if("${CMAKE_GENERATOR}" MATCHES "Makefiles")
+				add_custom_command(TARGET ${_target}
+					POST_BUILD
+					COMMAND
+					${CMAKE_COMMAND}
+					ARGS -E copy "${_res}" "${_path}/"
+					COMMENT "Copying ${_name} to ${_path}/")
+			else()
+				foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+					add_custom_command(TARGET ${_target}
+						POST_BUILD
+						COMMAND
+						${CMAKE_COMMAND}
+						ARGS -E copy "${_res}" "${_path${_config}}"
+						COMMENT "Copying ${_name} to ${_path${_config}}")
+				endforeach()
+
+			endif()
+		endif()
+	endforeach()
+endfunction()

CMakeModules/GetForceIncludeDefinitions.cmake

@@ -0,0 +1,44 @@
+# - Get the platform-appropriate flags to add to force inclusion of a file
+#
+# The most common use of this is to use a generated config.h-type file
+# placed out of the source tree in all files.
+#
+#  get_force_include_definitions(var forcedincludefiles...) -
+#   where var is the name of  your desired output variable, and everything
+#   else is a source file to forcibly include.
+#   a list item to be filtered.
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_force_include_definitions)
+	return()
+endif()
+set(__get_force_include_definitions YES)
+
+function(get_force_include_definitions var)
+	set(_flagprefix)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(_flag "-include")
+	elseif(MSVC)
+		set(_flag "/FI")
+	else()
+		message(SEND_ERROR "You don't seem to be using MSVC or GCC, but")
+		message(SEND_ERROR "the project called get_force_include_definitions.")
+		message(SEND_ERROR "Contact this project with the name of your")
+		message(FATAL_ERROR "compiler and preferably the flag to force includes")
+	endif()
+
+	set(_out)
+	foreach(_item ${ARGN})
+		list(APPEND _out "${_flag} \"${_item}\"")
+	endforeach()
+	set(${var} "${_out}" PARENT_SCOPE)
+endfunction()

CMakeModules/OldGNUInstallDirs.cmake

@@ -0,0 +1,182 @@
+# - Define GNU standard installation directories
+# Provides install directory variables as defined for GNU software:
+#  http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+# Inclusion of this module defines the following variables:
+#  CMAKE_INSTALL_<dir>      - destination for files of a given type
+#  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+# where <dir> is one of:
+#  BINDIR           - user executables (bin)
+#  SBINDIR          - system admin executables (sbin)
+#  LIBEXECDIR       - program executables (libexec)
+#  SYSCONFDIR       - read-only single-machine data (etc)
+#  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
+#  LOCALSTATEDIR    - modifiable single-machine data (var)
+#  LIBDIR           - object code libraries (lib or lib64)
+#  INCLUDEDIR       - C header files (include)
+#  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
+#  DATAROOTDIR      - read-only architecture-independent data root (share)
+#  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
+#  INFODIR          - info documentation (DATAROOTDIR/info)
+#  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
+#  MANDIR           - man documentation (DATAROOTDIR/man)
+#  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of
+# install() commands for the corresponding file type.  If the includer does
+# not define a value the above-shown default will be used and the value will
+# appear in the cache for editing by the user.
+# Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# from the corresponding destination by prepending (if necessary) the value
+# of CMAKE_INSTALL_PREFIX.
+
+#=============================================================================
+# Copyright 2011 Nikita Krupen'ko <krnekit@gmail.com>
+# Copyright 2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Installation directories
+#
+if(NOT DEFINED CMAKE_INSTALL_BINDIR)
+  set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SBINDIR)
+  set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR)
+  set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR)
+  set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR)
+  set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR)
+  set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+  set(_LIBDIR_DEFAULT "lib")
+  # Override this default 'lib' with 'lib64' iff:
+  #  - we are on Linux system but NOT cross-compiling
+  #  - we are NOT on debian
+  #  - we are on a 64 bits system
+  # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
+  # Note that the future of multi-arch handling may be even
+  # more complicated than that: http://wiki.debian.org/Multiarch
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux"
+      AND NOT CMAKE_CROSSCOMPILING
+      AND NOT EXISTS "/etc/debian_version")
+    if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+      message(AUTHOR_WARNING
+        "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+        "Please enable at least one language before including GNUInstallDirs.")
+    else()
+      if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        set(_LIBDIR_DEFAULT "lib64")
+      endif()
+    endif()
+  endif()
+  set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+  set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR)
+  set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR)
+  set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)")
+endif()
+
+#-----------------------------------------------------------------------------
+# Values whose defaults are relative to DATAROOTDIR.  Store empty values in
+# the cache and store the defaults in local variables if the cache values are
+# not set explicitly.  This auto-updates the defaults as DATAROOTDIR changes.
+
+if(NOT CMAKE_INSTALL_DATADIR)
+  set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)")
+  set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}")
+endif()
+
+if(NOT CMAKE_INSTALL_INFODIR)
+  set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)")
+  set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCALEDIR)
+  set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)")
+  set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale")
+endif()
+
+if(NOT CMAKE_INSTALL_MANDIR)
+  set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)")
+  set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man")
+endif()
+
+if(NOT CMAKE_INSTALL_DOCDIR)
+  set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)")
+  set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}")
+endif()
+
+#-----------------------------------------------------------------------------
+
+mark_as_advanced(
+  CMAKE_INSTALL_BINDIR
+  CMAKE_INSTALL_SBINDIR
+  CMAKE_INSTALL_LIBEXECDIR
+  CMAKE_INSTALL_SYSCONFDIR
+  CMAKE_INSTALL_SHAREDSTATEDIR
+  CMAKE_INSTALL_LOCALSTATEDIR
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_INCLUDEDIR
+  CMAKE_INSTALL_OLDINCLUDEDIR
+  CMAKE_INSTALL_DATAROOTDIR
+  CMAKE_INSTALL_DATADIR
+  CMAKE_INSTALL_INFODIR
+  CMAKE_INSTALL_LOCALEDIR
+  CMAKE_INSTALL_MANDIR
+  CMAKE_INSTALL_DOCDIR
+  )
+
+# Result directories
+#
+foreach(dir
+    BINDIR
+    SBINDIR
+    LIBEXECDIR
+    SYSCONFDIR
+    SHAREDSTATEDIR
+    LOCALSTATEDIR
+    LIBDIR
+    INCLUDEDIR
+    OLDINCLUDEDIR
+    DATAROOTDIR
+    DATADIR
+    INFODIR
+    LOCALEDIR
+    MANDIR
+    DOCDIR
+    )
+  if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}})
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}")
+  else()
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}")
+  endif()
+endforeach()

CMakeModules/SimGearComponent.cmake

@@ -0,0 +1,29 @@
+
+macro(simgear_component_common name includePath sourcesList sources headers)
+    set(fc${sourcesList} ${name})
+    set(fh${sourcesList} ${name})
+    foreach(s ${sources})
+        set_property(GLOBAL
+            APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+        set(fc${sourcesList} "${fc${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+    endforeach()
+
+	foreach(h ${headers})
+		set_property(GLOBAL
+			APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+        set(fh${sourcesList} "${fh${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+	endforeach()
+
+    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_C "${fc${sourcesList}}@")
+    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_H "${fh${sourcesList}}@")
+    
+    install (FILES ${headers}  DESTINATION include/simgear/${includePath})
+endmacro()
+
+function(simgear_component name includePath sources headers)
+    simgear_component_common(${name} ${includePath} CORE_SOURCES "${sources}" "${headers}")
+endfunction()
+
+function(simgear_scene_component name includePath sources headers)
+    simgear_component_common(${name} ${includePath} SCENE_SOURCES "${sources}" "${headers}")
+endfunction()

CMakeModules/cmake_uninstall.cmake.in

@@ -0,0 +1,22 @@
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+    MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF()
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+
+FOREACH(file ${files})
+    MESSAGE(STATUS "Uninstalling \"${file}\"")
+    IF(EXISTS "${file}")
+        EXEC_PROGRAM(
+            "@CMAKE_COMMAND@" ARGS "-E remove \"${file}\""
+            OUTPUT_VARIABLE rm_out
+            RETURN_VALUE rm_retval
+            )
+        IF(NOT "${rm_retval}" STREQUAL 0)
+            MESSAGE(FATAL_ERROR "Problem when removing \"${file}\"")
+        ENDIF()
+    ELSE()
+        MESSAGE(STATUS "File \"${file}\" does not exist.")
+    ENDIF()
+ENDFOREACH()

COPYING

@@ -2,7 +2,7 @@
                        Version 2, June 1991
 
  Copyright (C) 1991 Free Software Foundation, Inc.
-                    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -464,7 +464,7 @@ convey the exclusion of warranty; and each file should have at least the
 
     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
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
 Also add information on how to contact you by electronic and paper mail.
 

INSTALL

@@ -0,0 +1,56 @@
+How to build SimGear
+====================
+
+SimGear uses the CMake build system to generate a platform-specific
+build environment.  CMake reads the CMakeLists.txt files that you'll
+find throughout the source directories, checks for installed
+dependencies and then generates the appropriate build system.
+
+If you don't already have CMake installed on your system you can grab
+it from http://www.cmake.org, use version 2.6.4 or later.
+
+Under unices (i.e. Linux, Solaris, Free-BSD, HP-Ux, OSX) use the cmake
+or ccmake command-line utils. Preferably, create an out-of-source
+build directory and run cmake or ccmake from there. The advantage to
+this approach is that the temporary files created by CMake won't
+clutter the source directory, and also makes it possible to have
+multiple independent build targets by creating multiple build
+directories. In a directory alongside the SimGear source directory
+use:
+
+    mkdir sgbuild
+    cd sgbuild
+    cmake ../simgear -DCMAKE_BUILD_TYPE=Release
+    make
+    sudo make install
+
+
+Build Dependencies
+==================
+SimGear depends on a number of 3rd party libraries, the most notable
+being:
+
+* OpenSceneGraph (OSG) - see README.OSG
+* zlib compression library - see README.zlib
+* Open Audio Library (OpenAL) - see README.OpenAL
+* Subversion Client Library (optional dependency)
+
+
+Further information
+===================
+* README.cmake
+  for more detailed CMake instructions
+
+* README.msvc
+  in the FlightGear source package for more Windows-specific instructions
+
+* FlightGear Wiki
+  http://wiki.flightgear.org/Building_Flightgear
+
+* FlightGear Forums
+  For help on building see: http://www.flightgear.org/forums
+  => Support/Compiling
+
+* FlightGear Mailing lists
+  http://wiki.flightgear.org/index.php/Mailing_list
+

Makefile.am

@@ -1,25 +0,0 @@
-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
-
-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
-	rpm -ta $(PACKAGE)-$(VERSION).tar.gz
-

README

@@ -1 +1,15 @@
-[ Nothing here at this time. ]
+SimGear - Simulator Construction Tools
+======================================
+http://www.flightgear.org
+
+SimGear is a set of open-source libraries designed to be used as building
+blocks for quickly assembling 3d simulations, games, and visualization
+applications.
+
+SimGear is developed by the FlightGear project and also provides the base
+for the FlightGear Flight Simulator.
+
+Source code for SimGear is released under the GNU Library General Public
+License (LGPL) - see COPYING for license details.
+
+See INSTALL file for help on building SimGear.

README.MSVC

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

README.OSG

@@ -1,10 +1,9 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 
-You *must* have OpenSceneGraph (OSG) installed to build this version of 
+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. 
+Notice that this version of SimGear/FlightGear requires at least OSG 3.0.0.
 
 You can get the latest version of OSG from:
 
@@ -22,6 +21,6 @@ ccmake .
 [ While running ccmake: press 'c' to configure, press 'c' once more, and
   then press 'g' to generate and exit ]
 
-make 
+make
 sudo make install
 

README.OpenAL

@@ -18,12 +18,3 @@ ccmake .
   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
-

README.cmake

@@ -0,0 +1,161 @@
+Getting started with CMake
+==========================
+
+(These instructions apply to Unix-like systems, including Cygwin and Mac. To
+build using Visual Studio or some other IDE supported by CMake, most of the
+information below still applies. Otherwise see
+http://wiki.flightgear.org/Building_Flightgear for Windows specific build
+instructions.)
+
+Always compile in a separate directory to the code. For example, if the
+code (eg, from Git) is at /home/curt/projects/simgear, you might create
+/home/curt/projects/sgbuild. Change into the new directory, and run
+
+    cmake ../simgear
+
+To generate standard Unix Makefiles in sgbuild.
+
+Probably you want to specify an install prefix:
+
+    cmake ../simgear -DCMAKE_INSTALL_PREFIX=/usr
+
+Note the install prefix is automatically searched for required libraries
+and header files, so if you install OpenSceneGraph to the same prefix,
+most configuration options are unnecessary.
+
+If for some reason you have a dependency (or several) at a different prefix,
+you can specify one or more via CMAKE_PREFIX_PATH:
+
+    cmake ../simgear -DCMAKE_PREFIX_PATH="/opt/local;/opt/fgfs"
+
+(note the use of semi-colons to specify multiple prefix paths)
+
+Standard prefixes are searched automatically (/usr, /usr/local, /opt/local)
+
+Most dependencies also expose an environment variable to specify their
+installation directory explicitly eg OSG_DIR. Any of the methods
+described above will work, but specifying an INSTALL_PREFIX or PREFIX_PATH is
+usually simpler.
+
+By default, we select a release build. To create a debug build, use
+
+    cmake ../simgear -DCMAKE_BUILD_TYPE=Debug
+
+(or MinSizeRel, or RelWithDbg)
+
+Debug builds will automatically use corresponding debug builds of required
+libraries, if they are available. For example you can install debug builds of
+OpenSceneGraph, and a debug SimGear build will use them.
+
+(Debug builds of libraries have the 'd' suffix by default - Release builds
+have no additional suffix)
+
+Note most IDE projects (eg Xcode and Visual Studio) support building all the
+build types from the same project, so you can omit the CMAKE_BUILD_TYPE option
+when running cmake, and simply pick the build configuration as normal in the
+IDE.
+
+It's common to have several build directories with different build
+configurations, eg
+
+    /home/curt/projects/simgear (the git clone)
+    /home/curt/projects/sgdebug
+    /home/curt/projects/sgrelease
+    /home/curt/projects/sg-with-svn-osg
+
+To set an optional feature, do
+
+    cmake ../simgear -DFEATURE_NAME=ON
+
+(or 'OFF' to disable )
+
+To see the variables that can be configured / are currently defined, you can
+run one of the GUI front ends, or the following command:
+
+    cmake ../simgear -L
+
+Add 'A' to see all the options (including advanced options), or 'H' to see
+the help for each option (similar to running configure --help under autoconf):
+
+    cmake ../simgear -LH
+
+
+Build Targets
+=============
+
+For a Unix makefile build, 'make dist', 'make uninstall' and 'make test' are
+all available and should work as expected. 'make clean' is also as normal,
+but there is *no* 'make distclean' target. The equivalent is to completely
+remove your build directory, and start with a fresh one.
+
+Adding new files to the build
+
+Add source files to the SOURCES list, and headers to the HEADERS list. Note
+technically you only need to add source files, but omitting headers confuses
+project generation and distribution / packaging targets.
+
+For target conditional files, you can append to the SOURCES or HEADERS lists
+inside an if() test, for example:
+
+    if(APPLE)
+        list(APPEND SOURCES extraFile1.cxx extraFile2.cxx)
+    endif()
+
+Setting include directories
+
+In any CMakeList.txt, you can do the following:
+
+    include_directories(${PROJECT_SOURCE_DIR}/some/path)
+
+For example, this can be done in particular subdirectory, or at the project
+root, or an intermediate level.
+
+Setting target specific compile flags, includes or defines
+
+Use set_target_property(), for example
+
+    set_target_property(fgfs PROPERTIES
+            COMPILE_DEFINITIONS FOO BAR=1)
+
+You can set a property on an individual source file:
+
+    set_property(SOURCE myfile.cxx PROPERTY COMPILE_FLAGS "-Wno-unsigned-compare")
+
+Detecting Features / Libraries
+
+For most standard libraries (Gtk, wxWidget, Python, GDAL, Qt, libXml, Boost),
+cmake provides a standard helper. To see the available modules, run:
+
+     cmake --help-module-list
+
+In the root CMakeLists file, use a statement like:
+
+    find_package(OpenGL REQUIRED)
+
+Each package helper sets various variables such aaa_FOUND, aaa_INCLUDE_DIR,
+and aaa_LIBRARY. Depending on the complexity of the package, these variables
+might have different names (eg, OPENSCENEGRAPH_LIBRARIES).
+
+If there's no standard helper for a library you need, find a similar one, copy
+it to CMakeModules/FindABC.cmake, and modify the code to fit. Generally this
+is pretty straightforward. The built-in modules reside in the Cmake 'share'
+directory, eg /usr/share/cmake/modules on Unix systems.
+
+Note libraries support by pkg-config can be handled directly, with no need
+to create a custom FindABC helper.
+
+Adding a new executable target
+
+    add_executable(myexecutable ${SOURCES} ${HEADERS})
+    target_link_libraries(myexecutable .... libraries ... )
+    install(TARGETS myexecutable RUNTIME DESTINATION bin)
+
+(If the executable should not be installed, omit the final line above)
+
+If you add an additional line
+
+    add_test(testname ${EXECUTABLE_OUTPUT_PATH}/myexecutable)
+
+Then running 'make test' will run your executable as a unit test. The
+executable should return either a success or failure result code.
+

README.plib

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

SimGear.dsw

@@ -1,29 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "SimGear"=".\SimGear.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

TODO

@@ -1 +0,0 @@
-03/25/2001 - Resolve location of Sky dome implimentation documentation.

acinclude.m4

@@ -1,686 +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${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_NOTICE([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
-
-])

am2dsp.cfg

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

autogen.sh

@@ -1,52 +0,0 @@
-#!/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 "======================================"

configure.ac

@@ -1,525 +0,0 @@
-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.0)
-
-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.34.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
-
-# 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
-
-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)
-
-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"
-    # not sure how to test if OpenAL exists on MacOS (does it come by default?)
-    OPENAL_OK="yes"
-    ALUT_OK="yes"
-    ;;
-
-*)
-    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
-
-AC_LANG_PUSH(C++)
-
-dnl Check for "plib" without which we cannot go on
-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() {
-    int major, minor, micro;
-
-    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"
-
-AC_CHECK_HEADER(osg/Version)
-if test "x$ac_cv_header_osg_Version" != "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
-
-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/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
-

package/RedHat/README

@@ -0,0 +1,13 @@
+Building a SimGear RPM package for Red Hat
+
+Please see the "package/openSUSE" directory for an
+example how to build a SimGear RPM package with
+shared SimGear libraries.
+
+You may need to adapt the names (exact spelling) of some
+of the package dependencies in the openSUSE RPM spec,
+since these may slightly differ for Red Hat.
+
+(If you have a working and tested Red Hat RPM spec,
+you're welcome to contribute it to this project.)
+

package/openSUSE/README

@@ -0,0 +1,23 @@
+Building a SimGear RPM package for openSUSE
+
+(Last tested with openSUSE 11.4+12.1)
+
+This directory contains the files which, along with
+the source code tar files, can be used to build
+an RPM package targeted at an openSUSE Linux system.
+
+To build SimGear from source do the following:
+
+1. obtain simgear-2.8.0.tar.bz2 (adapt version if
+    necessary) and copy it into ~/rpmbuild/SOURCES
+
+2. look in the BuildRequires section of SimGear.spec
+   and check that all the packages referred to are
+   installed (note, some of these packages may be part
+   of openSUSE's "games" repository).
+
+3. run 'rpmbuild -ba simgear.spec' and find the RPM
+   build result in ~/rpmbuild/RPMS
+
+That's all!
+

package/openSUSE/SimGear.spec

@@ -0,0 +1,63 @@
+Summary:    Simulator Construction Gear
+Name:       SimGear
+Version:    2.8.0
+Release:    1
+License:    LGPL
+URL:        http://www.flightgear.org
+Group:      Amusements/Games/3D/Simulation
+Source:     http://mirrors.ibiblio.org/pub/mirrors/flightgear/ftp/Source/simgear-%{version}.tar.bz2
+BuildRoot:  %{_tmppath}/%{name}-%{version}-build
+
+BuildRequires: gcc, gcc-c++, cmake
+BuildRequires: libopenal1-soft, openal-soft
+BuildRequires: libOpenSceneGraph-devel >= 3.0
+BuildRequires: zlib, zlib-devel
+BuildRequires: libjpeg62, libjpeg62-devel
+BuildRequires: boost-devel >= 1.37
+BuildRequires: subversion-devel, libapr1-devel
+Requires:      OpenSceneGraph-plugins >= 3.0
+
+%description
+This package contains a tools and libraries useful for constructing
+simulation and visualization applications such as FlightGear or TerraGear.
+
+%package devel
+Group:         Development/Libraries/Other
+Summary:       Development header files for SimGear
+Requires:      SimGear = %{version}
+
+%description devel
+Development headers and libraries for building applications against SimGear.
+
+%prep
+%setup -T -q -n simgear-%{version} -b 0
+
+%build
+export CFLAGS="$RPM_OPT_FLAGS"
+export CXXFLAGS="$RPM_OPT_FLAGS"
+# build SHARED simgear libraries
+cmake -DCMAKE_INSTALL_PREFIX=%{_prefix} -DSIMGEAR_SHARED:BOOL=ON -DENABLE_TESTS:BOOL=OFF -DJPEG_FACTORY:BOOL=ON
+make %{?_smp_mflags}
+
+%install
+make DESTDIR=%{buildroot} install
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%files
+%defattr (-, root, root, -)
+%doc AUTHORS COPYING ChangeLog NEWS README
+%{_libdir}/libSimGear*.so.*
+
+%files devel
+%defattr(-,root,root,-)
+%dir %{_includedir}/simgear
+%{_includedir}/simgear/*
+%{_libdir}/libSimGear*.so
+
+%changelog
+* Mon Jul 02 2012 thorstenb@flightgear.org
+- Initial version
+

projects/VC7.1/.cvsignore

@@ -1,4 +0,0 @@
-Debug
-Release
-SimGear.ncb
-SimGear.suo

projects/VC7.1/SimGear.sln

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

projects/VC8/SimGear.sln

@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual C++ Express 2005
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear", "SimGear.vcproj", "{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Debug|Win32.ActiveCfg = Debug|Win32
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Debug|Win32.Build.0 = Debug|Win32
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Release|Win32.ActiveCfg = Release|Win32
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

simgear/.cvsignore

@@ -1,8 +0,0 @@
-Makefile
-Makefile.in
-simgear_config.h
-simgear_config.h.in
-stamp-h
-stamp-h.in
-stamp-h1
-version.h

simgear/.gitignore

@@ -0,0 +1,2 @@
+simgear_config.h
+version.h

simgear/CMakeLists.txt

@@ -0,0 +1,143 @@
+
+file(WRITE ${PROJECT_BINARY_DIR}/simgear/version.h "#define SIMGEAR_VERSION ${SIMGEAR_VERSION}")
+
+foreach( mylibfolder 
+        bucket
+        bvh
+        debug
+        ephemeris
+        io
+        magvar
+        math
+        misc
+        nasal
+        nasal/cppbind
+        props
+        serial
+        structure
+        threads
+        timing
+        xml
+        package
+    )
+
+    add_subdirectory(${mylibfolder})
+
+endforeach( mylibfolder )
+
+if(NOT SIMGEAR_HEADLESS)
+    add_subdirectory(canvas)
+    add_subdirectory(environment)
+    add_subdirectory(screen)
+    add_subdirectory(scene)
+    add_subdirectory(sound)
+endif(NOT SIMGEAR_HEADLESS)
+
+
+if(ENABLE_RTI)
+    add_subdirectory(hla)
+endif(ENABLE_RTI)
+
+
+set(HEADERS compiler.h constants.h sg_inlines.h ${PROJECT_BINARY_DIR}/simgear/version.h)
+install (FILES ${HEADERS}  DESTINATION include/simgear/)
+
+get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
+get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
+get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
+get_property(localExpatSources GLOBAL PROPERTY LOCAL_EXPAT_SOURCES)
+
+if(SIMGEAR_SHARED)
+    message(STATUS "Library building mode: SHARED LIBRARIES")
+    add_library(SimGearCore SHARED ${coreSources} ${localExpatSources})
+
+    set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
+    set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
+    set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+    install(TARGETS SimGearCore EXPORT SimGearCoreConfig LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install(EXPORT SimGearCoreConfig DESTINATION share/SimGearCore)
+    
+    if(NOT SIMGEAR_HEADLESS)
+        add_library(SimGearScene SHARED ${sceneSources})
+        set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
+        set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
+        set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+
+        # EXPORT SimGearSceneConfig
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
+    #    install(EXPORT SimGearSceneConfig DESTINATION share/SimGearScene)
+    endif()
+    
+else()
+    message(STATUS "Library building mode: STATIC LIBRARIES")
+
+	get_property(FG_GROUPS_CORE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_CORE_SOURCES_C)
+	string(REPLACE "@" ";" groups ${FG_GROUPS_CORE_SOURCES_C} )
+	foreach(g ${groups})
+		string(REPLACE "#" ";" g2 ${g})
+		list(GET g2 0 name)
+		list(REMOVE_AT g2 0)
+		source_group("${name}\\Sources" FILES ${g2})
+	endforeach()
+
+	get_property(FG_GROUPS_CORE_SOURCES_H GLOBAL PROPERTY FG_GROUPS_CORE_SOURCES_H)
+	string(REPLACE "@" ";" groups ${FG_GROUPS_CORE_SOURCES_H} )
+	foreach(g ${groups})
+		string(REPLACE "#" ";" g2 ${g})
+		list(GET g2 0 name)
+		list(REMOVE_AT g2 0)
+		source_group("${name}\\Headers" FILES ${g2})
+	endforeach()
+
+    add_library(SimGearCore STATIC ${coreSources} ${localExpatSources})
+    install(TARGETS SimGearCore ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    
+    if(NOT SIMGEAR_HEADLESS)
+		get_property(FG_GROUPS_SCENE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_C)
+		string(REPLACE "@" ";" groups ${FG_GROUPS_SCENE_SOURCES_C} )
+		foreach(g ${groups})
+			string(REPLACE "#" ";" g2 ${g})
+			list(GET g2 0 name)
+			list(REMOVE_AT g2 0)
+			source_group("${name}\\Sources" FILES ${g2})
+		endforeach()
+
+		get_property(FG_GROUPS_SCENE_SOURCES_H GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_H)
+		string(REPLACE "@" ";" groups ${FG_GROUPS_SCENE_SOURCES_H} )
+		foreach(g ${groups})
+			string(REPLACE "#" ";" g2 ${g})
+			list(GET g2 0 name)
+			list(REMOVE_AT g2 0)
+			source_group("${name}\\Headers" FILES ${g2})
+		endforeach()
+
+        add_library(SimGearScene STATIC ${sceneSources})
+        install(TARGETS SimGearScene ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif(NOT SIMGEAR_HEADLESS)
+endif(SIMGEAR_SHARED)
+
+target_link_libraries(SimGearCore
+    ${ZLIB_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${EXPAT_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${COCOA_LIBRARY})
+
+if(NOT SIMGEAR_HEADLESS)
+    target_link_libraries(SimGearScene
+        SimGearCore
+        ${ZLIB_LIBRARY}
+        ${OPENSCENEGRAPH_LIBRARIES}
+        ${OPENAL_LIBRARY}
+        ${OPENGL_LIBRARY}
+        ${JPEG_LIBRARY})
+endif()
+
+if(ENABLE_RTI)
+    # Ugly first aid to make hla compile agian
+    set_property(SOURCE hla/RTI13InteractionClass.cxx hla/RTI13ObjectClass.cxx
+        hla/RTI13ObjectInstance.cxx hla/RTI13Federate.cxx
+        hla/RTI13FederateFactory.cxx
+        APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
+endif(ENABLE_RTI)

simgear/Makefile.am

@@ -1,37 +0,0 @@
-if HAVE_THREADS
-SGTHREAD_DIR = threads
-else
-SGTHREAD_DIR = 
-endif
-
-# METAR_DIRS =
-METAR_DIRS = environment
-
-EXTRA_DIST = simgear_config.h.vc5 simgear_config.h-msvc71 version.h.in
-
-include_HEADERS = \
-	compiler.h constants.h sg_inlines.h version.h
-
-SUBDIRS = \
-	$(compatibility_DIR) \
-	xml \
-	debug \
-	misc \
-	structure \
-	bucket \
-	ephemeris \
-	io \
-	magvar \
-	math \
-	$(METAR_DIRS) \
-	nasal \
-	props \
-	route \
-	scene \
-	screen \
-	serial \
-	sound \
-	$(SGTHREAD_DIR) \
-	timing
-
-DIST_SUBDIRS = $(SUBDIRS) compatibility

simgear/bucket/.cvsignore

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

simgear/bucket/CMakeLists.txt

@@ -0,0 +1,16 @@
+
+include (SimGearComponent)
+
+set(HEADERS newbucket.hxx)
+set(SOURCES newbucket.cxx)
+
+simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")
+
+
+if(ENABLE_TESTS)
+
+add_executable(test_bucket test_bucket.cxx)
+add_test(test_bucket ${EXECUTABLE_OUTPUT_PATH}/test_bucket)
+target_link_libraries(test_bucket ${TEST_LIBS})
+
+endif(ENABLE_TESTS)

simgear/bucket/Makefile.am

@@ -1,17 +0,0 @@
-includedir = @includedir@/bucket
-
-lib_LIBRARIES = libsgbucket.a
-
-include_HEADERS = newbucket.hxx
-
-libsgbucket_a_SOURCES = newbucket.cxx
-
-# noinst_PROGRAMS = testbucket
-
-# testbucket_SOURCES = testbucket.cxx
-
-# testbucket_LDADD = \
-# 	libsgbucket.a \
-# 	$(top_builddir)/misc/libsgmisc.a
-
-INCLUDES = -I$(top_srcdir)

simgear/bucket/newbucket.cxx

@@ -27,36 +27,56 @@
 #  include <simgear_config.h>
 #endif
 
-#include <math.h>
+#include <cmath>
+#include <cstdio> // some platforms need this for ::snprintf
+#include <iostream>
 
 #include <simgear/misc/sg_path.hxx>
+#include <simgear/debug/logstream.hxx>
 
 #include "newbucket.hxx"
 
 
 // default constructor
-SGBucket::SGBucket() {
+SGBucket::SGBucket() :
+    lon(-1000),
+    lat(-1000),
+    x(0),
+    y(0)
+{
 }
 
+bool SGBucket::isValid() const
+{
+    // The most northerly valid latitude is 89, not 90. There is no tile
+    // whose *bottom* latitude is 90. Similar there is no tile whose left egde
+    // is 180 longitude.
+    return (lon >= -180) &&
+            (lon < 180) &&
+            (lat >= -90) &&
+            (lat < 90) &&
+            (x < 8) && (y < 8);
+}
+
+void SGBucket::make_bad()
+{
+    lon = -1000;
+    lat = -1000;
+}
+
+#ifndef NO_DEPRECATED_API
 
 // constructor for specified location
 SGBucket::SGBucket(const double dlon, const double dlat) {
     set_bucket(dlon, dlat);
 }
+#endif
 
 SGBucket::SGBucket(const SGGeod& geod) {
-    set_bucket(geod);
+    innerSet(geod.getLongitudeDeg(),
+             geod.getLatitudeDeg());
 }
 
-// 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;
@@ -75,71 +95,97 @@ SGBucket::SGBucket(const long int bindex) {
     x = index;
 }
 
+/* Calculate the greatest integral value less than
+ * or equal to the given value (floor(x)),
+ * but attribute coordinates close to the boundary to the next
+ * (increasing) integral
+ */
+static int floorWithEpsilon(double x)
+{
+    return static_cast<int>(floor(x + SG_EPSILON));
+}
 
-// Set the bucket params for the specified lat and lon
-void SGBucket::set_bucket( double *lonlat ) {
-    set_bucket( lonlat[0], lonlat[1] );
-}	
+#ifndef NO_DEPRECATED_API
 
-
-// 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) || (fabs(diff) < SG_EPSILON) ) {
-	    lon = (int)( (int)(lon / span) * span);
-	} else {
-	    // cout << " lon = " << lon 
-	    //  << "  tmp = " << (int)((lon-1) / span) << endl;
-	    lon = (int)( (int)((lon + 1) / span) * span - span);
-	    if ( lon < -180 ) {
-		lon = -180;
-	    }
-	}
-	x = 0;
-    }
-
-    //
-    // then latitude
-    //
-    diff = dlat - (double)(int)dlat;
-
-    if ( (dlat >= 0) || (fabs(diff) < SG_EPSILON) ) {
-	lat = (int)dlat;
-    } else {
-	lat = (int)dlat - 1;
-    }
-    y = (int)((dlat - lat) * 8);
+void SGBucket::set_bucket(double dlon, double dlat)
+{
+    innerSet(dlon, dlat);
 }
 
 
 void SGBucket::set_bucket(const SGGeod& geod)
 {
-    set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
+    innerSet(geod.getLongitudeDeg(), geod.getLatitudeDeg());
+}
+
+#endif
+
+// Set the bucket params for the specified lat and lon
+void SGBucket::innerSet( double dlon, double dlat )
+{
+    if ((dlon < -180.0) || (dlon >= 180.0)) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed longitude:" << dlon);
+        dlon = SGMiscd::normalizePeriodic(-180.0, 180.0, dlon);
+    }
+    
+    if ((dlat < -90.0) || (dlat > 90.0)) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed latitude" << dlat);
+        dlat = SGMiscd::clip(dlat, -90.0, 90.0);
+    }
+    
+    //
+    // longitude first
+    //
+    double span = sg_bucket_span( dlat );
+    // we do NOT need to special case lon=180 here, since
+    // normalizePeriodic will never return 180; it will
+    // return -180, which is what we want.
+    lon = floorWithEpsilon(dlon);
+    
+    // find subdivision or super lon if needed
+    if ( span <= 1.0 ) {
+        /* We have more than one tile per degree of
+         * longitude, so we need an x offset.
+         */
+        x = floorWithEpsilon((dlon - lon) / span);
+    } else {
+        /* We have one or more degrees per tile,
+         * so we need to find the base longitude
+         * of that tile.
+         *
+         * First we calculate the integral base longitude
+         * (e.g. -85.5 => -86) and then find the greatest
+         * multiple of span that is less than or equal to
+         * that longitude.
+         *
+         * That way, the Greenwich Meridian is always
+         * a tile border.
+         */
+        lon=static_cast<int>(floor(lon / span) * span);
+        x = 0;
+    }
+
+    //
+    // then latitude
+    //
+    lat = floorWithEpsilon(dlat);
+    
+    // special case when passing in the north pole point (possibly due to
+    // clipping latitude above). Ensures we generate a valid bucket in this
+    // scenario
+    if (lat == 90) {
+        lat = 89;
+        y = 7;
+    } else {
+        /* Latitude base and offset are easier, as
+         * tiles always are 1/8 degree of latitude wide.
+         */
+        y = floorWithEpsilon((dlat - lat) * 8);
+    }
 }
 
 // Build the path name for this bucket
-string SGBucket::gen_base_path() const {
+std::string SGBucket::gen_base_path() const {
     // long int index;
     int top_lon, top_lat, main_lon, main_lat;
     char hem, pole;
@@ -177,7 +223,7 @@ string SGBucket::gen_base_path() const {
 	main_lat *= -1;
     }
 
-    sprintf(raw_path, "%c%03d%c%02d/%c%03d%c%02d", 
+    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d",
 	    hem, top_lon, pole, top_lat, 
 	    hem, main_lon, pole, main_lat);
 
@@ -198,22 +244,37 @@ 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 SGBucket::get_highest_lat() const
+{
+    unsigned char adjustedY = y;
+    if (lat >= 0) {
+        // tile is north of the equator, so we want the top edge. Add one
+        // to y to achieve this.
+        ++adjustedY;
     }
-    double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
+    
+	return lat + (adjustedY / 8.0);
+}
+
+
+// return width of the tile in meters. This function is used by the
+// tile-manager to estimate how many tiles are in the view distance, so
+// we care about the smallest width, which occurs at the highest latitude.
+double SGBucket::get_width_m() const
+{
+    double clat_rad = get_highest_lat() * SGD_DEGREES_TO_RADIANS;
     double cos_lat = cos( clat_rad );
+    if (fabs(cos_lat) < SG_EPSILON) {
+        // happens for polar tiles, since we pass in a latitude of 90
+        // return an arbitrary small value so all tiles are loaded
+        return 10.0;
+    }
+    
     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 get_width() * degree_width;
 }
 
 
@@ -225,7 +286,41 @@ double SGBucket::get_height_m() const {
     return SG_BUCKET_SPAN * degree_height;
 }
 
+SGBucket SGBucket::sibling(int dx, int dy) const
+{
+    if (!isValid()) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
+        return SGBucket();
+    }
+    
+    double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
+    // return invalid here instead of clipping, so callers can discard
+    // invalid buckets without having to check if it's an existing one
+    if ((clat < -90.0) || (clat > 90.0)) {
+        return SGBucket();
+    }
+    
+    // find the lon span for the new latitude
+    double span = sg_bucket_span( clat );
+    
+    double tmp = get_center_lon() + dx * span;
+    tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
+    
+    SGBucket b;
+    b.innerSet(tmp, clat);
+    return b;
+}
 
+std::string SGBucket::gen_index_str() const
+{
+	char tmp[20];
+	::snprintf(tmp, 20, "%ld",
+                 (((long)lon + 180) << 14) + ((lat + 90) << 6)
+                 + (y << 3) + x);
+	return (std::string)tmp;
+}
+
+#ifndef NO_DEPRECATED_API
 // 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
@@ -252,7 +347,7 @@ SGBucket sgBucketOffset( double dlon, double dlat, int dx, int dy ) {
 
     return result;
 }
-
+#endif
 
 // calculate the offset between two buckets
 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
@@ -310,4 +405,25 @@ void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
 #endif
 }
 
+void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list ) {
+    double lon, lat, span;
+
+    for (lat = min.getLatitudeDeg(); lat < max.getLatitudeDeg()+SG_BUCKET_SPAN; lat += SG_BUCKET_SPAN) {
+        span = sg_bucket_span( lat );
+        for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span)
+        {
+            SGBucket b(SGGeod::fromDeg(lon, lat));
+            if (!b.isValid()) {
+                continue;
+            }
+            
+            list.push_back(b);
+        }
+    }
+}
+
+std::ostream& operator<< ( std::ostream& out, const SGBucket& b )
+{
+    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
+}
 

simgear/bucket/newbucket.hxx

@@ -24,6 +24,11 @@
 
 /** \file newbucket.hxx
  * A class and associated utiltity functions to manage world scenery tiling.
+ *
+ * Tile borders are aligned along circles of latitude and longitude.
+ * All tiles are 1/8 degree of latitude high and their width in degrees
+ * longitude depends on their latitude, adjusted in such a way that
+ * all tiles cover about the same amount of area of the earth surface.
  */
 
 #ifndef _NEWBUCKET_HXX
@@ -34,9 +39,11 @@
 #include <simgear/math/SGMath.hxx>
 
 #include <cmath>
-#include <cstdio> // sprintf()
-#include <ostream>
 #include <string>
+#include <iosfwd>
+#include <vector>
+
+// #define NO_DEPRECATED_API
 
 /**
  * standard size of a bucket in degrees (1/8 of a degree)
@@ -52,9 +59,7 @@
 // return the horizontal tile span factor based on latitude
 static double sg_bucket_span( double l ) {
     if ( l >= 89.0 ) {
-	return 360.0;
-    } else if ( l >= 88.0 ) {
-	return 8.0;
+	return 12.0;
     } else if ( l >= 86.0 ) {
 	return 4.0;
     } else if ( l >= 83.0 ) {
@@ -75,12 +80,10 @@ static double sg_bucket_span( double l ) {
 	return 1.0;
     } else if ( l >= -86.0 ) {
 	return 2.0;
-    } else if ( l >= -88.0 ) {
-	return 4.0;
     } else if ( l >= -89.0 ) {
-	return 8.0;
+	return 4.0;
     } else {
-	return 360.0;
+	return 12.0;
     }
 }
 
@@ -95,26 +98,33 @@ static double sg_bucket_span( double l ) {
 class SGBucket {
 
 private:
-    double cx, cy;  // centerpoint (lon, lat) in degrees of bucket
     short lon;        // longitude index (-180 to 179)
     short lat;        // latitude index (-90 to 89)
-    char x;          // x subdivision (0 to 7)
-    char y;          // y subdivision (0 to 7)
+    unsigned char x;          // x subdivision (0 to 7)
+    unsigned char y;          // y subdivision (0 to 7)
 
+    void innerSet( double dlon, double dlat );
 public:
 
     /**
-     * Default constructor.
+     * Default constructor, creates an invalid SGBucket
      */
     SGBucket();
 
+    /**
+     * Check if this bucket refers to a valid tile, or not.
+     */
+    bool isValid() const;
+    
+#ifndef NO_DEPRECATED_API
     /**
      * 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);
-
+#endif
+    
     /**
      * Construct a bucket given a specific location.
      * @param dlon longitude specified in degrees
@@ -122,33 +132,12 @@ public:
      */
     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 );
-
+#ifndef NO_DEPRECATED_API
     /**
      * Reset a bucket to represent a new lat and lon
      * @param dlon longitude specified in degrees
@@ -156,17 +145,23 @@ public:
      */
     void set_bucket(const SGGeod& geod);
 
+
+    /**
+     * 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 );
+#endif
+    
     /**
      * 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;
-    }
-
+    void make_bad();
+    
     /**
      * Generate the unique scenery tile index for this bucket
      *
@@ -191,14 +186,8 @@ public:
      * 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;
-    }
-
+    std::string gen_index_str() const;
+    
     /**
      * Build the base path name for this bucket.
      * @return base path in string form
@@ -212,9 +201,9 @@ public:
 	double span = sg_bucket_span( lat + y / 8.0 + SG_HALF_BUCKET_SPAN );
 
 	if ( span >= 1.0 ) {
-	    return lon + span / 2.0;
+	    return lon + get_width() / 2.0;
 	} else {
-	    return lon + x * span + span / 2.0;
+	    return lon + x * span + get_width() / 2.0;
 	}
     }
 
@@ -225,6 +214,13 @@ public:
 	return lat + y / 8.0 + SG_HALF_BUCKET_SPAN;
     }
 
+    /**
+     * @return the highest (furthest from the equator) latitude of this
+     * tile. This is the top edge for tiles north of the equator, and
+     * the bottom edge for tiles south
+     */
+    double get_highest_lat() const;
+    
     /**
      * @return the width of the tile in degrees.
      */
@@ -286,6 +282,11 @@ public:
      */
     inline int get_y() const { return y; }
 
+    /**
+     * @return bucket offset from this by dx,dy
+     */
+    SGBucket sibling(int dx, int dy) const;
+    
     // friends
 
     friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
@@ -297,7 +298,7 @@ inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
         return !(lhs == rhs);
     }
 
-
+#ifndef NO_DEPRECATED_API
 /**
  * \relates SGBucket
  * Return the bucket which is offset from the specified dlon, dlat by
@@ -309,6 +310,7 @@ inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
  * @return offset bucket
  */
 SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
+#endif
 
 
 /**
@@ -322,17 +324,21 @@ SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy );
 
 
+/**
+ * \relates SGBucket
+ * retrieve a list of buckets in the given bounding box
+ * @param min min lon,lat of bounding box in degrees
+ * @param max max lon,lat of bounding box in degrees
+ * @param list standard vector of buckets within the bounding box
+ */
+void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list );
+
 /**
  * Write the bucket lon, lat, x, and y to the output stream.
  * @param out output stream
  * @param b bucket
  */
-inline std::ostream&
-operator<< ( std::ostream& out, const SGBucket& b )
-{
-    return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
-}
-
+std::ostream& operator<< ( std::ostream& out, const SGBucket& b );
 
 /**
  * Compare two bucket structures for equality.

simgear/bucket/test_bucket.cxx

@@ -0,0 +1,283 @@
+/**************************************************************************
+ * test_bucket.cxx -- unit-tests for SGBucket class
+ *
+ * Copyright (C) 2014  James Turner - <zakalawe@mac.com>
+ *
+ * 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 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$
+ **************************************************************************/
+
+#include <simgear/compiler.h>
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+#include <simgear/bucket/newbucket.hxx>
+#include <simgear/misc/test_macros.hxx>
+
+void testBucketSpans()
+{
+    COMPARE(sg_bucket_span(0.0), 0.125);
+    COMPARE(sg_bucket_span(-20), 0.125);
+    COMPARE(sg_bucket_span(-40), 0.25);
+    COMPARE(sg_bucket_span(89.9), 12.0);
+    COMPARE(sg_bucket_span(88.1), 4.0);
+    COMPARE(sg_bucket_span(-89.9), 12.0);
+}
+
+void testBasic()
+{
+    SGBucket b1(5.1, 55.05);
+    COMPARE(b1.get_chunk_lon(), 5);
+    COMPARE(b1.get_chunk_lat(), 55);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 0);
+    COMPARE(b1.gen_index(), 3040320);
+    COMPARE(b1.gen_base_path(), "e000n50/e005n55");
+    VERIFY(b1.isValid());
+    
+    SGBucket b2(-10.1, -43.8);
+    COMPARE(b2.get_chunk_lon(), -11);
+    COMPARE(b2.get_chunk_lat(), -44);
+    COMPARE(b2.get_x(), 3);
+    COMPARE(b2.get_y(), 1); // latitude chunks numbered bottom to top, it seems
+    COMPARE(b2.gen_base_path(), "w020s50/w011s44");
+    VERIFY(b2.isValid());
+    
+    SGBucket b3(123.48, 9.01);
+    COMPARE(b3.get_chunk_lon(), 123);
+    COMPARE(b3.get_chunk_lat(), 9);
+    COMPARE(b3.get_x(), 3);
+    COMPARE(b3.get_y(), 0);
+    COMPARE(b3.gen_base_path(), "e120n00/e123n09");
+    VERIFY(b3.isValid());
+    
+    SGBucket defBuck;
+    VERIFY(!defBuck.isValid());
+    
+    b3.make_bad();
+    VERIFY(!b3.isValid());
+
+    SGBucket atAntiMeridian(180.0, 12.3);
+    VERIFY(atAntiMeridian.isValid());
+    COMPARE(atAntiMeridian.get_chunk_lon(), -180);
+    COMPARE(atAntiMeridian.get_x(), 0);
+    
+    SGBucket atAntiMeridian2(-180.0, -78.1);
+    VERIFY(atAntiMeridian2.isValid());
+    COMPARE(atAntiMeridian2.get_chunk_lon(), -180);
+    COMPARE(atAntiMeridian2.get_x(), 0);
+    
+// check comparisom operator overload
+    SGBucket b4(5.11, 55.1);
+    VERIFY(b1 == b4); // should be equal
+    VERIFY(b1 == b1);
+    VERIFY(b1 != defBuck);
+    VERIFY(b1 != b2);
+    
+// check wrapping/clipping of inputs
+    SGBucket wrapMeridian(-200.0, 45.0);
+    COMPARE(wrapMeridian.get_chunk_lon(), 160);
+    
+    SGBucket clipPole(48.9, 91);
+    COMPARE(clipPole.get_chunk_lat(), 89);
+}
+
+void testPolar()
+{
+    SGBucket b1(0.0, 89.92);
+    SGBucket b2(10.0, 89.96);
+    COMPARE(b1.get_chunk_lat(), 89);
+    COMPARE(b1.get_chunk_lon(), 0);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 7);
+    
+    COMPARE_EP(b1.get_highest_lat(), 90.0);
+    COMPARE_EP(b1.get_width_m(), 10.0);
+    
+    COMPARE(b2.get_chunk_lat(), 89);
+    COMPARE(b2.get_chunk_lon(), 0);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 7);
+    
+    COMPARE(b1.gen_index(), b2.gen_index());
+    
+    SGGeod actualNorthPole1 = b1.get_corner(2);
+    SGGeod actualNorthPole2 = b1.get_corner(3);
+    COMPARE_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
+    COMPARE_EP(actualNorthPole1.getLongitudeDeg(), 12.0);
+    COMPARE_EP(actualNorthPole2.getLatitudeDeg(), 90.0);
+    COMPARE_EP(actualNorthPole2.getLongitudeDeg(), 0.0);
+
+    SGBucket b3(-2, 89.88);
+    SGBucket b4(-7, 89.88);
+    COMPARE(b3.gen_index(), b4.gen_index());
+    
+    // south pole
+    SGBucket b5(-170, -89.88);
+    SGBucket b6(-179, -89.88);
+    
+    COMPARE(b5.get_chunk_lat(), -90);
+    COMPARE(b5.get_chunk_lon(), -180);
+    COMPARE(b5.get_x(), 0);
+    COMPARE(b5.get_y(), 0);
+    COMPARE(b5.gen_index(), b6.gen_index());
+    COMPARE_EP(b5.get_highest_lat(), -90.0);
+    COMPARE_EP(b5.get_width_m(), 10.0);
+    
+    SGGeod actualSouthPole1 = b5.get_corner(0);
+    SGGeod actualSouthPole2 = b5.get_corner(1);
+    COMPARE_EP(actualSouthPole1.getLatitudeDeg(), -90.0);
+    COMPARE_EP(actualSouthPole1.getLongitudeDeg(), -180);
+    COMPARE_EP(actualSouthPole2.getLatitudeDeg(), -90.0);
+    COMPARE_EP(actualSouthPole2.getLongitudeDeg(), -168);
+    
+    SGBucket b7(200, 89.88);
+    COMPARE(b7.get_chunk_lon(), -168);
+
+}
+
+// test the tiles just below the pole (between 86 & 89 degrees N/S)
+void testNearPolar()
+{
+    SGBucket b1(1, 88.5);
+    SGBucket b2(-1, 88.8);
+    COMPARE(b1.get_chunk_lon(), 0);
+    COMPARE(b1.get_chunk_lat(), 88);
+    VERIFY(b1.gen_index() != b2.gen_index());
+
+    SGBucket b3(176.1, 88.5);
+    COMPARE(b3.get_chunk_lon(), 176);
+    
+    SGBucket b4(-178, 88.5);
+    COMPARE(b4.get_chunk_lon(), -180);
+}
+
+void testOffset()
+{
+    // bucket just below the 22 degree cutoff, so the next tile north
+    // is twice the width
+    SGBucket b1(-59.8, 21.9);
+    COMPARE(b1.get_chunk_lat(), 21);
+    COMPARE(b1.get_chunk_lon(), -60);
+    COMPARE(b1.get_x(), 1);
+    COMPARE(b1.get_y(), 7);
+    
+    // offset vertically
+    SGBucket b2(b1.sibling(0, 1));
+    COMPARE(b2.get_chunk_lat(), 22);
+    COMPARE(b2.get_chunk_lon(), -60);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 0);
+
+    COMPARE(b2.gen_index(), sgBucketOffset(-59.8, 21.9, 0, 1));
+    
+    // offset vertically and horizontally. We compute horizontal (x)
+    // movement at the target latitude, so this should move 0.25 * -3 degrees,
+    // NOT 0.125 * -3 degrees.
+    SGBucket b3(b1.sibling(-3, 1));
+    COMPARE(b3.get_chunk_lat(), 22);
+    COMPARE(b3.get_chunk_lon(), -61);
+    COMPARE(b3.get_x(), 1);
+    COMPARE(b3.get_y(), 0);
+    
+    COMPARE(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
+}
+
+void testPolarOffset()
+{
+    SGBucket b1(-11.7, -89.6);
+    COMPARE(b1.get_chunk_lat(), -90);
+    COMPARE(b1.get_chunk_lon(), -12);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 3);
+    
+    // offset horizontally
+    SGBucket b2(b1.sibling(-2, 0));
+    COMPARE(b2.get_chunk_lat(), -90);
+    COMPARE(b2.get_chunk_lon(), -36);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 3);
+    
+    COMPARE(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
+    
+// offset and wrap
+    SGBucket b3(-170, 89.1);
+    SGBucket b4(b3.sibling(-1, 0));
+    COMPARE(b4.get_chunk_lat(), 89);
+    COMPARE(b4.get_chunk_lon(), 168);
+    COMPARE(b4.get_x(), 0);
+    COMPARE(b4.get_y(), 0);
+    
+    COMPARE(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));
+
+    
+    SGBucket b5(177, 87.3);
+    SGBucket b6(b5.sibling(1, 1));
+    COMPARE(b6.get_chunk_lat(), 87);
+    COMPARE(b6.get_chunk_lon(), -180);
+    COMPARE(b6.get_x(), 0);
+    COMPARE(b6.get_y(), 3);
+    
+    COMPARE(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));
+
+    // offset vertically towards the pole
+    SGBucket b7(b1.sibling(0, -5));
+    VERIFY(!b7.isValid());
+    
+    VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
+}
+
+// test behaviour of bucket-offset near the anti-meridian (180-meridian)
+void testOffsetWrap()
+{
+    // near the equator
+    SGBucket b1(-179.8, 16.8);
+    COMPARE(b1.get_chunk_lat(), 16);
+    COMPARE(b1.get_chunk_lon(), -180);
+    COMPARE(b1.get_x(), 1);
+    COMPARE(b1.get_y(), 6);
+    
+    SGBucket b2(b1.sibling(-2, 0));
+    COMPARE(b2.get_chunk_lat(), 16);
+    COMPARE(b2.get_chunk_lon(), 179);
+    COMPARE(b2.get_x(), 7);
+    COMPARE(b2.get_y(), 6);
+    COMPARE(b2.gen_index(), sgBucketOffset(-179.8, 16.8, -2, 0));
+    
+    
+}
+
+int main(int argc, char* argv[])
+{
+    testBucketSpans();
+    
+    testBasic();
+    testPolar();
+    testNearPolar();
+    testOffset();
+    testOffsetWrap();
+    testPolarOffset();
+    
+    cout << "all tests passed OK" << endl;
+    return 0; // passed
+}
+

simgear/bvh/.gitignore

@@ -0,0 +1,2 @@
+bvhtest
+

simgear/bvh/BVHBoundingBoxVisitor.hxx

@@ -0,0 +1,83 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHBoundingBoxVisitor_hxx
+#define BVHBoundingBoxVisitor_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHPageNode.hxx"
+#include "BVHTransform.hxx"
+#include "BVHMotionTransform.hxx"
+#include "BVHLineGeometry.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+#include "BVHStaticGeometry.hxx"
+
+namespace simgear {
+
+class BVHBoundingBoxVisitor : public BVHVisitor {
+public:
+    virtual ~BVHBoundingBoxVisitor() {}
+    
+    void clear()
+    { _box.clear(); }
+    
+    virtual void apply(BVHGroup& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHPageNode& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHTransform& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHMotionTransform& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHLineGeometry& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHStaticGeometry& node)
+    { expandBy(node.getBoundingSphere()); }
+    
+    virtual void apply(const BVHStaticBinary& node, const BVHStaticData& data)
+    { expandBy(node.getBoundingBox()); }
+    virtual void apply(const BVHStaticTriangle& node, const BVHStaticData& data)
+    { expandBy(node.computeBoundingBox(data)); }
+    
+    const SGBoxf& getBox() const
+    { return _box; }
+    
+private:
+    void expandBy(const SGSphered& sphere)
+    {
+        SGVec3f v0(sphere.getCenter() - sphere.getRadius()*SGVec3d(1, 1, 1));
+        SGVec3f v1(sphere.getCenter() + sphere.getRadius()*SGVec3d(1, 1, 1));
+        _box.expandBy(SGBoxf(v0, v1));
+    }
+    void expandBy(const SGBoxf& box)
+    { _box.expandBy(box); }
+    
+    SGBoxf _box;
+};
+
+}
+
+#endif

simgear/bvh/BVHGroup.cxx

@@ -0,0 +1,92 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHGroup.hxx"
+
+#include <algorithm>
+
+namespace simgear {
+
+BVHGroup::BVHGroup()
+{
+}
+
+BVHGroup::~BVHGroup()
+{
+    ChildList::iterator i;
+    for (i = _children.begin(); i != _children.end(); ++i) {
+        (*i)->removeParent(this);
+        *i = 0;
+    }
+}
+
+void
+BVHGroup::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+BVHGroup::clear()
+{
+    _children.clear();
+    invalidateBound();
+}
+
+void
+BVHGroup::addChild(BVHNode* child)
+{
+    if (!child)
+        return;
+    ChildList::iterator i;
+    i = std::find(_children.begin(), _children.end(), child);
+    if (i != _children.end())
+        return;
+    invalidateBound();
+    child->addParent(this);
+    _children.push_back(child);
+}
+
+void
+BVHGroup::removeChild(BVHNode* child)
+{
+    if (!child)
+        return;
+    ChildList::iterator i;
+    i = std::find(_children.begin(), _children.end(), child);
+    if (i == _children.end())
+        return;
+    invalidateBound();
+    child->removeParent(this);
+    _children.erase(i);
+}
+
+SGSphered
+BVHGroup::computeBoundingSphere() const
+{
+    SGSphered sphere;
+    ChildList::const_iterator i;
+    for (i = _children.begin(); i != _children.end(); ++i)
+        sphere.expandBy((*i)->getBoundingSphere());
+    return sphere;
+}
+
+}

simgear/bvh/BVHGroup.hxx

@@ -0,0 +1,61 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHGroup_hxx
+#define BVHGroup_hxx
+
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "BVHNode.hxx"
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+class BVHGroup : public BVHNode {
+public:
+    BVHGroup();
+    virtual ~BVHGroup();
+    
+    virtual void accept(BVHVisitor& visitor);
+    
+    void traverse(BVHVisitor& visitor)
+    {
+        ChildList::const_iterator i;
+        for (i = _children.begin(); i != _children.end(); ++i)
+            (*i)->accept(visitor);
+    }
+    
+    void clear();
+    void addChild(BVHNode* child);
+    void removeChild(BVHNode* child);
+    
+    unsigned getNumChildren() const
+    { return _children.size(); }
+    const BVHNode* getChild(unsigned i) const
+    { if (_children.size() <= i) return 0; return _children[i]; }
+    BVHNode* getChild(unsigned i)
+    { if (_children.size() <= i) return 0; return _children[i]; }
+    
+    virtual SGSphered computeBoundingSphere() const;
+    
+private:
+    typedef std::vector<SGSharedPtr<BVHNode> > ChildList;
+    ChildList _children;
+};
+
+}
+
+#endif

simgear/bvh/BVHLineGeometry.cxx

@@ -0,0 +1,49 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHLineGeometry.hxx"
+
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+BVHLineGeometry::BVHLineGeometry(const SGLineSegmentf& lineSegment, Type type) :
+    _lineSegment(lineSegment),
+    _type(type)
+{
+}
+
+BVHLineGeometry::~BVHLineGeometry()
+{
+}
+
+void
+BVHLineGeometry::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+SGSphered
+BVHLineGeometry::computeBoundingSphere() const
+{
+    SGSphered sphere;
+    sphere.expandBy(SGVec3d(_lineSegment.getStart()));
+    sphere.expandBy(SGVec3d(_lineSegment.getEnd()));
+    return sphere;
+}
+
+}

simgear/bvh/BVHLineGeometry.hxx

@@ -0,0 +1,53 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHLineGeometry_hxx
+#define BVHLineGeometry_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include "BVHNode.hxx"
+
+namespace simgear {
+
+class BVHLineGeometry : public BVHNode {
+public:
+    enum Type {
+        CarrierCatapult,
+        CarrierWire
+    };
+
+    BVHLineGeometry(const SGLineSegmentf& lineSegment, Type type);
+    virtual ~BVHLineGeometry();
+
+    virtual void accept(BVHVisitor& visitor);
+
+    const SGLineSegmentf& getLineSegment() const
+    { return _lineSegment; }
+
+    Type getType() const
+    { return _type; }
+
+    virtual SGSphered computeBoundingSphere() const;
+
+private:
+    SGLineSegmentf _lineSegment;
+    Type _type;
+};
+
+}
+
+#endif

simgear/bvh/BVHLineSegmentVisitor.cxx

@@ -0,0 +1,166 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHLineSegmentVisitor.hxx"
+
+#include <simgear/math/SGGeometry.hxx>
+
+#include "BVHVisitor.hxx"
+
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHPageNode.hxx"
+#include "BVHTransform.hxx"
+#include "BVHMotionTransform.hxx"
+#include "BVHLineGeometry.hxx"
+#include "BVHStaticGeometry.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+
+namespace simgear {
+
+void
+BVHLineSegmentVisitor::apply(BVHGroup& group)
+{
+    if (!intersects(_lineSegment, group.getBoundingSphere()))
+        return;
+    group.traverse(*this);
+}
+
+void
+BVHLineSegmentVisitor::apply(BVHPageNode& pageNode)
+{
+    if (!intersects(_lineSegment, pageNode.getBoundingSphere()))
+        return;
+    pageNode.traverse(*this);
+}
+    
+void
+BVHLineSegmentVisitor::apply(BVHTransform& transform)
+{
+    if (!intersects(_lineSegment, transform.getBoundingSphere()))
+        return;
+    
+    bool haveHit = _haveHit;
+    _haveHit = false;
+    
+    // Push the line segment
+    SGLineSegmentd lineSegment = getLineSegment();
+    _lineSegment = transform.lineSegmentToLocal(lineSegment);
+    
+    transform.traverse(*this);
+    
+    if (_haveHit) {
+        _linearVelocity = transform.vecToWorld(_linearVelocity);
+        _angularVelocity = transform.vecToWorld(_angularVelocity);
+        SGVec3d point(transform.ptToWorld(_lineSegment.getEnd()));
+        _lineSegment.set(lineSegment.getStart(), point);
+        _normal = transform.vecToWorld(_normal);
+    } else {
+        _lineSegment = lineSegment;
+        _haveHit = haveHit;
+    }
+}
+
+void
+BVHLineSegmentVisitor::apply(BVHMotionTransform& transform)
+{
+    if (!intersects(_lineSegment, transform.getBoundingSphere()))
+        return;
+    
+    bool haveHit = _haveHit;
+    _haveHit = false;
+
+    // Push the line segment
+    SGLineSegmentd lineSegment = getLineSegment();
+    SGMatrixd toLocal = transform.getToLocalTransform(_time);
+    _lineSegment = lineSegment.transform(toLocal);
+    
+    transform.traverse(*this);
+    
+    if (_haveHit) {
+        SGMatrixd toWorld = transform.getToWorldTransform(_time);
+        SGVec3d localStart = _lineSegment.getStart();
+        _linearVelocity += transform.getLinearVelocityAt(localStart);
+        _angularVelocity += transform.getAngularVelocity();
+        _linearVelocity = toWorld.xformVec(_linearVelocity);
+        _angularVelocity = toWorld.xformVec(_angularVelocity);
+        SGVec3d localEnd = _lineSegment.getEnd();
+        _lineSegment.set(lineSegment.getStart(), toWorld.xformPt(localEnd));
+        _normal = toWorld.xformVec(_normal);
+        if (!_id)
+            _id = transform.getId();
+    } else {
+        _lineSegment = lineSegment;
+        _haveHit = haveHit;
+    }
+}
+
+void
+BVHLineSegmentVisitor::apply(BVHLineGeometry&)
+{
+}
+    
+void
+BVHLineSegmentVisitor::apply(BVHStaticGeometry& node)
+{
+    if (!intersects(_lineSegment, node.getBoundingSphere()))
+        return;
+    node.traverse(*this);
+}
+
+void
+BVHLineSegmentVisitor::apply(const BVHStaticBinary& node,
+                             const BVHStaticData& data)
+{
+    if (!intersects(SGLineSegmentf(_lineSegment), node.getBoundingBox()))
+        return;
+    
+    // The first box to enter is the one the startpoint is in.
+    // this increases the probability, that on exit of that box we do not
+    // even need to walk the other one, since the line segment is
+    // then already short enough to not intersect the other one anymore.
+    node.traverse(*this, data, _lineSegment.getStart());
+}
+
+void
+BVHLineSegmentVisitor::apply(const BVHStaticTriangle& triangle,
+                             const BVHStaticData& data)
+{
+    SGTrianglef tri = triangle.getTriangle(data);
+    SGVec3f point;
+    if (!intersects(point, tri, SGLineSegmentf(_lineSegment), 1e-4f))
+        return;
+    setLineSegmentEnd(SGVec3d(point));
+    _normal = SGVec3d(tri.getNormal());
+    _linearVelocity = SGVec3d::zeros();
+    _angularVelocity = SGVec3d::zeros();
+    _material = data.getMaterial(triangle.getMaterialIndex());
+    _id = 0;
+    _haveHit = true;
+}
+
+
+}

simgear/bvh/BVHLineSegmentVisitor.hxx

@@ -0,0 +1,100 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHLineSegmentVisitor_hxx
+#define BVHLineSegmentVisitor_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+
+namespace simgear {
+
+class BVHMaterial;
+
+class BVHLineSegmentVisitor : public BVHVisitor {
+public:
+    BVHLineSegmentVisitor(const SGLineSegmentd& lineSegment,
+                          const double& t = 0) :
+        _lineSegment(lineSegment),
+        _time(t),
+        _material(0),
+        _id(0),
+        _haveHit(false)
+    { }
+    virtual ~BVHLineSegmentVisitor()
+    { }
+    
+    bool empty() const
+    { return !_haveHit; }
+    
+    const SGLineSegmentd& getLineSegment() const
+    { return _lineSegment; }
+    
+    SGVec3d getPoint() const
+    { return _lineSegment.getEnd(); }
+    const SGVec3d& getNormal() const
+    { return _normal; }
+    const SGVec3d& getLinearVelocity() const
+    { return _linearVelocity; }
+    const SGVec3d& getAngularVelocity() const
+    { return _angularVelocity; }
+    const BVHMaterial* getMaterial() const
+    { return _material; }
+    BVHNode::Id getId() const
+    { return _id; }
+
+    virtual void apply(BVHGroup& group);
+    virtual void apply(BVHPageNode& node);
+    virtual void apply(BVHTransform& transform);
+    virtual void apply(BVHMotionTransform& transform);
+    virtual void apply(BVHLineGeometry&);
+    virtual void apply(BVHStaticGeometry& node);
+    
+    virtual void apply(const BVHStaticBinary&, const BVHStaticData&);
+    virtual void apply(const BVHStaticTriangle&, const BVHStaticData&);
+    
+protected:
+    void setLineSegmentEnd(const SGVec3d& end)
+    {
+        // Ok, you need to make sure that the new end is in the previous
+        // direction and that the line segment is not enlarged by that call.
+#ifndef _NDEBUG
+        // FIXME insert code to check this...
+#endif
+        _lineSegment.set(_lineSegment.getStart(), end);
+    }
+    
+private:
+    SGLineSegmentd _lineSegment;
+    double _time;
+    
+    // belongs in a derived class
+    SGVec3d _normal;
+    SGVec3d _linearVelocity;
+    SGVec3d _angularVelocity;
+    const BVHMaterial* _material;
+    BVHNode::Id _id;
+    
+    bool _haveHit;
+};
+
+}
+
+#endif

simgear/bvh/BVHMaterial.cxx

@@ -1,5 +1,4 @@
-// PathOptions.cxx -- make an osgDB Options object from a path
-// Copyright (C) 2007  Tim Moore timoore@redhat.com
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,19 +14,22 @@
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
-// $Id$
 
-#include <osgDB/Registry>
+#include "BVHMaterial.hxx"
 
-#include "PathOptions.hxx"
+namespace simgear {
 
-using namespace simgear;
-
-osgDB::ReaderWriter::Options* simgear::makeOptionsFromPath(const SGPath& path)
+BVHMaterial::BVHMaterial() :
+    _solid(true),
+    _friction_factor(1),
+    _rolling_friction(0.02),
+    _bumpiness(0),
+    _load_resistance(1e30)
 {
-    using namespace osgDB;
-    ReaderWriter::Options *options
-        = new ReaderWriter::Options(*(Registry::instance()->getOptions()));
-    options->setDatabasePath(path.str());
-    return options;
+}
+
+BVHMaterial::~BVHMaterial()
+{
+}
+
 }

simgear/bvh/BVHMaterial.hxx

@@ -0,0 +1,75 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHMaterial_hxx
+#define BVHMaterial_hxx
+
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHMaterial : public SGReferenced {
+public:
+    BVHMaterial();
+    virtual ~BVHMaterial();
+
+    /**
+     * Return if the surface material is solid, if it is not solid, a fluid
+     * can be assumed, that is usually water.
+     */
+    bool get_solid () const { return _solid; }
+    
+    /**
+     * Get the friction factor for that material
+     */
+    double get_friction_factor () const { return _friction_factor; }
+    
+    /**
+     * Get the rolling friction for that material
+     */
+    double get_rolling_friction () const { return _rolling_friction; }
+    
+    /**
+     * Get the bumpines for that material
+     */
+    double get_bumpiness () const { return _bumpiness; }
+    
+    /**
+     * Get the load resistance
+     */
+    double get_load_resistance () const { return _load_resistance; }
+
+protected:    
+    // True if the material is solid, false if it is a fluid
+    bool _solid;
+    
+    // the friction factor of that surface material
+    double _friction_factor;
+    
+    // the rolling friction of that surface material
+    double _rolling_friction;
+    
+    // the bumpiness of that surface material
+    double _bumpiness;
+    
+    // the load resistance of that surface material
+    double _load_resistance;
+};
+
+}
+
+#endif

simgear/bvh/BVHMotionTransform.cxx

@@ -0,0 +1,120 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHMotionTransform.hxx"
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+
+namespace simgear {
+
+BVHMotionTransform::BVHMotionTransform() :
+    _toWorldReference(SGMatrixd::unit()),
+    _toLocalReference(SGMatrixd::unit()),
+    _toWorldAmplification(1),
+    _toLocalAmplification(1),
+    _linearVelocity(0, 0, 0),
+    _angularVelocity(0, 0, 0),
+    _referenceTime(0),
+    _startTime(0),
+    _endTime(0),
+    _id(0)
+{
+}
+
+BVHMotionTransform::~BVHMotionTransform()
+{
+}
+
+void
+BVHMotionTransform::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+BVHMotionTransform::setTransform(const BVHMotionTransform& transform)
+{
+    _toWorldReference = transform._toWorldReference;
+    _toLocalReference = transform._toLocalReference;
+    _toWorldAmplification = transform._toWorldAmplification;
+    _toLocalAmplification = transform._toLocalAmplification;
+    _linearVelocity = transform._linearVelocity;
+    _angularVelocity = transform._angularVelocity;
+    _referenceTime = transform._referenceTime;
+    _startTime = transform._startTime;
+    _endTime = transform._endTime;
+    _id = transform._id;
+    invalidateParentBound();
+}
+
+void
+BVHMotionTransform::setToWorldTransform(const SGMatrixd& transform)
+{
+    _toWorldReference = transform;
+    invert(_toLocalReference, transform);
+    updateAmplificationFactors();
+    invalidateParentBound();
+}
+
+void
+BVHMotionTransform::setToLocalTransform(const SGMatrixd& transform)
+{
+    _toLocalReference = transform;
+    invert(_toWorldReference, transform);
+    updateAmplificationFactors();
+    invalidateParentBound();
+}
+
+SGSphered
+BVHMotionTransform::computeBoundingSphere() const
+{
+    SGSphered sphere(BVHGroup::computeBoundingSphere());
+    if (sphere.empty())
+        return sphere;
+    SGMatrixd toWorldStart = getToWorldTransform(_startTime);
+    SGVec3d centerStart = toWorldStart.xformPt(sphere.getCenter());
+    SGMatrixd toWorldEnd = getToWorldTransform(_endTime);
+    SGVec3d centerEnd = toWorldEnd.xformPt(sphere.getCenter());
+    double rad = 0.5*length(centerStart - centerEnd) + sphere.getRadius();
+    rad *= _toWorldAmplification;
+    return SGSphered(0.5*(centerStart + centerEnd), rad);
+}
+
+void
+BVHMotionTransform::updateAmplificationFactors()
+{
+    // Hmm, this is just a hint, true?
+    // But anyway, almost all transforms in a scenegraph will
+    // have them equal to 1 ...
+    double r = norm(_toWorldReference.xformVec(SGVec3d(1, 0, 0)));
+	r = SGMiscd::max(r, norm(_toWorldReference.xformVec(SGVec3d(0, 1, 0))));
+    r = SGMiscd::max(r, norm(_toWorldReference.xformVec(SGVec3d(0, 0, 1))));
+    _toWorldAmplification = r;
+    
+    r = norm(_toLocalReference.xformVec(SGVec3d(1, 0, 0)));
+    r = SGMiscd::max(r, norm(_toLocalReference.xformVec(SGVec3d(0, 1, 0))));
+    r = SGMiscd::max(r, norm(_toLocalReference.xformVec(SGVec3d(0, 0, 1))));
+    _toLocalAmplification = r;
+}
+
+}

simgear/bvh/BVHMotionTransform.hxx

@@ -0,0 +1,126 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHMotionTransform_hxx
+#define BVHMotionTransform_hxx
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+
+namespace simgear {
+
+class BVHMotionTransform : public BVHGroup {
+public:
+    BVHMotionTransform();
+    virtual ~BVHMotionTransform();
+
+    virtual void accept(BVHVisitor& visitor);
+
+    void setTransform(const BVHMotionTransform& transform);
+    void setToWorldTransform(const SGMatrixd& transform);
+    void setToLocalTransform(const SGMatrixd& transform);
+
+    void setLinearVelocity(const SGVec3d& linearVelocity)
+    { _linearVelocity = linearVelocity; }
+    const SGVec3d& getLinearVelocity() const
+    { return _linearVelocity; }
+
+    void setAngularVelocity(const SGVec3d& angularVelocity)
+    { _angularVelocity = angularVelocity; }
+    const SGVec3d& getAngularVelocity() const
+    { return _angularVelocity; }
+
+    void setReferenceTime(const double& referenceTime)
+    { _referenceTime = referenceTime; }
+    const double& getReferenceTime() const
+    { return _referenceTime; }
+
+    void setStartTime(const double& startTime)
+    { _startTime = startTime; }
+    const double& getStartTime() const
+    { return _startTime; }
+
+    void setEndTime(const double& endTime)
+    { _endTime = endTime; }
+    const double& getEndTime() const
+    { return _endTime; }
+    
+    SGMatrixd getToWorldTransform(const double& t) const
+    {
+        if (t == _referenceTime)
+            return _toWorldReference;
+        double dt = t - _referenceTime;
+        SGMatrixd matrix(_toWorldReference);
+        matrix.postMultRotate(SGQuatd::fromAngleAxis(dt*_angularVelocity));
+        matrix.postMultTranslate(dt*_linearVelocity);
+        return matrix;
+    }
+    SGMatrixd getToLocalTransform(const double& t) const
+    {
+        if (t == _referenceTime)
+            return _toLocalReference;
+        double dt = _referenceTime - t;
+        SGMatrixd matrix(_toLocalReference);
+        matrix.preMultRotate(SGQuatd::fromAngleAxis(dt*_angularVelocity));
+        matrix.preMultTranslate(dt*_linearVelocity);
+        return matrix;
+    }
+
+    const SGMatrixd& getToWorldReferenceTransform() const
+    { return _toWorldReference; }
+    const SGMatrixd& getToLocalReferenceTransform() const
+    { return _toLocalReference; }
+
+    SGVec3d getLinearVelocityAt(const SGVec3d& reference) const
+    { return _linearVelocity + cross(_angularVelocity, reference); }
+
+    SGSphered sphereToLocal(const SGSphered& sphere, const double& t) const
+    {
+        SGMatrixd matrix = getToLocalTransform(t);
+        SGVec3d center = matrix.xformPt(sphere.getCenter());
+        double radius = _toLocalAmplification*sphere.getRadius();
+        return SGSphered(center, radius);
+    }
+
+    void setId(Id id)
+    { _id = id; }
+    Id getId() const
+    { return _id; }
+
+private:
+    virtual SGSphered computeBoundingSphere() const;
+    void updateAmplificationFactors();
+    
+    SGMatrixd _toWorldReference;
+    SGMatrixd _toLocalReference;
+    double _toWorldAmplification;
+    double _toLocalAmplification;
+
+    SGVec3d _linearVelocity;
+    SGVec3d _angularVelocity;
+
+    double _referenceTime;
+    double _startTime;
+    double _endTime;
+
+    Id _id;
+};
+
+}
+
+#endif

simgear/bvh/BVHNearestPointVisitor.hxx

@@ -0,0 +1,173 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHNearestPointVisitor_hxx
+#define BVHNearestPointVisitor_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+
+#include "BVHVisitor.hxx"
+
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHPageNode.hxx"
+#include "BVHTransform.hxx"
+#include "BVHLineGeometry.hxx"
+#include "BVHStaticGeometry.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+
+namespace simgear {
+
+class BVHNearestPointVisitor : public BVHVisitor {
+public:
+    BVHNearestPointVisitor(const SGSphered& sphere, const double& t) :
+        _sphere(sphere),
+        _time(t),
+        _material(0),
+        _id(0),
+        _havePoint(false)
+    { }
+    
+    virtual void apply(BVHGroup& leaf)
+    {
+        if (!intersects(_sphere, leaf.getBoundingSphere()))
+            return;
+        leaf.traverse(*this);
+    }
+    virtual void apply(BVHPageNode& leaf)
+    {
+        if (!intersects(_sphere, leaf.getBoundingSphere()))
+            return;
+        leaf.traverse(*this);
+    }
+    virtual void apply(BVHTransform& transform)
+    {
+        if (!intersects(_sphere, transform.getBoundingSphere()))
+            return;
+        
+        SGSphered sphere = _sphere;
+        _sphere = transform.sphereToLocal(sphere);
+        bool havePoint = _havePoint;
+        _havePoint = false;
+        
+        transform.traverse(*this);
+        
+        if (_havePoint) {
+            _point = transform.ptToWorld(_point);
+            _linearVelocity = transform.vecToWorld(_linearVelocity);
+            _angularVelocity = transform.vecToWorld(_angularVelocity);
+        }
+        _havePoint |= havePoint;
+        _sphere.setCenter(sphere.getCenter());
+    }
+    virtual void apply(BVHMotionTransform& transform)
+    {
+        if (!intersects(_sphere, transform.getBoundingSphere()))
+            return;
+        
+        SGSphered sphere = _sphere;
+        _sphere = transform.sphereToLocal(sphere, _time);
+        bool havePoint = _havePoint;
+        _havePoint = false;
+        
+        transform.traverse(*this);
+        
+        if (_havePoint) {
+            SGMatrixd toWorld = transform.getToWorldTransform(_time);
+            SGVec3d localCenter = _sphere.getCenter();
+            _linearVelocity += transform.getLinearVelocityAt(localCenter);
+            _angularVelocity += transform.getAngularVelocity();
+            _linearVelocity = toWorld.xformVec(_linearVelocity);
+            _angularVelocity = toWorld.xformVec(_angularVelocity);
+            _point = toWorld.xformPt(_point);
+            if (!_id)
+                _id = transform.getId();
+        }
+        _havePoint |= havePoint;
+        _sphere.setCenter(sphere.getCenter());
+    }
+    virtual void apply(BVHLineGeometry& node)
+    { }
+    virtual void apply(BVHStaticGeometry& node)
+    {
+        if (!intersects(_sphere, node.getBoundingSphere()))
+            return;
+        node.traverse(*this);
+    }
+    
+    virtual void apply(const BVHStaticBinary& node, const BVHStaticData& data)
+    {
+        if (!intersects(_sphere, node.getBoundingBox()))
+            return;
+        node.traverse(*this, data, _sphere.getCenter());
+    }
+    virtual void apply(const BVHStaticTriangle& node, const BVHStaticData& data)
+    {
+        SGVec3f center(_sphere.getCenter());
+        SGVec3d closest(closestPoint(node.getTriangle(data), center));
+        if (!intersects(_sphere, closest))
+            return;
+        _point = closest;
+        _linearVelocity = SGVec3d::zeros();
+        _angularVelocity = SGVec3d::zeros();
+        _material = data.getMaterial(node.getMaterialIndex());
+        // The trick is to decrease the radius of the search sphere.
+        _sphere.setRadius(length(closest - _sphere.getCenter()));
+        _havePoint = true;
+        _id = 0;
+    }
+    
+    void setSphere(const SGSphered& sphere)
+    { _sphere = sphere; }
+    const SGSphered& getSphere() const
+    { return _sphere; }
+    
+    const SGVec3d& getPoint() const
+    { return _point; }
+    const SGVec3d& getLinearVelocity() const
+    { return _linearVelocity; }
+    const SGVec3d& getAngularVelocity() const
+    { return _angularVelocity; }
+    const BVHMaterial* getMaterial() const
+    { return _material; }
+    BVHNode::Id getId() const
+    { return _id; }
+    
+    bool empty() const
+    { return !_havePoint; }
+    
+private:
+    SGSphered _sphere;
+    double _time;
+
+    SGVec3d _point;
+    SGVec3d _linearVelocity;
+    SGVec3d _angularVelocity;
+    const BVHMaterial* _material;
+    BVHNode::Id _id;
+
+    bool _havePoint;
+};
+
+}
+
+#endif

simgear/bvh/BVHNode.cxx

@@ -0,0 +1,80 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHNode.hxx"
+
+#include <algorithm>
+#include <simgear/structure/SGAtomic.hxx>
+#include <simgear/math/SGGeometry.hxx>
+
+namespace simgear {
+
+BVHNode::BVHNode() :
+    _dirtyBoundingSphere(true)
+{
+}
+
+BVHNode::~BVHNode()
+{
+}
+
+BVHNode::Id
+BVHNode::getNewId()
+{
+    static SGAtomic id(0);
+    return ++id;
+}
+
+void
+BVHNode::addParent(BVHNode* parent)
+{
+    // should not happen, but be paranoid ...
+    ParentList::iterator i;
+    i = std::find(_parents.begin(), _parents.end(), parent);
+    if (i != _parents.end())
+        return;
+    // add to the parents list ...
+    _parents.push_back(parent);
+}
+
+void
+BVHNode::removeParent(BVHNode* parent)
+{
+    ParentList::iterator i;
+    i = std::find(_parents.begin(), _parents.end(), parent);
+    if (i == _parents.end())
+        return;
+    _parents.erase(i);
+}
+
+void
+BVHNode::invalidateParentBound()
+{
+    for (ParentList::iterator i = _parents.begin(); i != _parents.end(); ++i)
+        (*i)->invalidateBound();
+}
+
+void
+BVHNode::invalidateBound()
+{
+    if (_dirtyBoundingSphere)
+        return;
+    invalidateParentBound();
+    _dirtyBoundingSphere = true;
+}
+
+}

simgear/bvh/BVHNode.hxx

@@ -0,0 +1,76 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHNode_hxx
+#define BVHNode_hxx
+
+#include <vector>
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHGroup;
+class BVHVisitor;
+class BVHPageNode;
+
+// Base for the tree nodes
+class BVHNode : public SGReferenced {
+public:
+    BVHNode();
+    virtual ~BVHNode();
+    
+    // visitors ...
+    virtual void accept(BVHVisitor& visitor) = 0;
+    
+    const SGSphered& getBoundingSphere() const
+    {
+        if (_dirtyBoundingSphere) {
+            _boundingSphere = computeBoundingSphere();
+            _dirtyBoundingSphere = false;
+        }
+        return _boundingSphere;
+    }
+    virtual SGSphered computeBoundingSphere() const = 0;
+
+    /// A unique id for some kind of BVHNodes.
+    /// Currently only motions transforms.
+    typedef unsigned Id;
+
+    // Factory to get a new id
+    static Id getNewId();
+    
+protected:
+    friend class BVHGroup;
+    friend class BVHPageNode;
+    void addParent(BVHNode* parent);
+    void removeParent(BVHNode* parent);
+    
+    void invalidateParentBound();
+    virtual void invalidateBound();
+    
+private:
+    mutable bool _dirtyBoundingSphere;
+    mutable SGSphered _boundingSphere;
+    
+    typedef std::vector<BVHNode*> ParentList;
+    ParentList _parents;
+};
+
+}
+
+#endif

simgear/bvh/BVHPageNode.cxx

@@ -0,0 +1,40 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHPageNode.hxx"
+
+#include "BVHPager.hxx"
+
+namespace simgear {
+
+BVHPageNode::BVHPageNode() :
+    _useStamp(0),
+    _requested(false)
+{
+}
+
+BVHPageNode::~BVHPageNode()
+{
+}
+
+void
+BVHPageNode::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+}

simgear/bvh/BVHPageNode.hxx

@@ -0,0 +1,66 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHPageNode_hxx
+#define BVHPageNode_hxx
+
+#include <list>
+
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHGroup.hxx"
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+class BVHPager;
+class BVHPageRequest;
+
+class BVHPageNode : public BVHGroup {
+public:
+    BVHPageNode();
+    virtual ~BVHPageNode();
+    
+    virtual void accept(BVHVisitor& visitor);
+
+    /// Return the usage stamp of the last access
+    unsigned getUseStamp() const
+    { return _useStamp; }
+
+    virtual SGSphered computeBoundingSphere() const = 0;
+
+    virtual BVHPageRequest* newRequest() = 0;
+
+protected:
+    virtual void invalidateBound() = 0;
+
+    bool getRequested() const
+    { return _requested; }
+    void setRequested(bool requested)
+    { _requested = requested; }
+
+private:
+    friend class BVHPager;
+
+    std::list<SGSharedPtr<BVHPageNode> >::iterator _iterator;
+    unsigned _useStamp;
+    bool _requested;
+};
+
+}
+
+#endif

simgear/bvh/BVHPageRequest.cxx

@@ -0,0 +1,26 @@
+// Copyright (C) 2008 - 2012 Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHPageRequest.hxx"
+
+namespace simgear {
+
+BVHPageRequest::~BVHPageRequest()
+{
+}
+
+}

simgear/bvh/BVHPageRequest.hxx

@@ -0,0 +1,42 @@
+// Copyright (C) 2008 - 2012 Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHPageRequest_hxx
+#define BVHPageRequest_hxx
+
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHPageNode;
+
+class BVHPageRequest : public SGReferenced {
+public:
+    virtual ~BVHPageRequest();
+
+    /// Happens in the pager thread, do not modify the calling bvh tree
+    virtual void load() = 0;
+    /// Happens in the bvh main thread where the bvh is actually used.
+    /// So inside here it is safe to modify the paged node
+    virtual void insert() = 0;
+    /// The page node this request is for
+    virtual BVHPageNode* getPageNode() = 0;
+};
+
+}
+
+#endif

simgear/bvh/BVHPager.cxx

@@ -0,0 +1,236 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHPager.hxx"
+
+#include <list>
+
+#include <simgear/threads/SGThread.hxx>
+#include <simgear/threads/SGGuard.hxx>
+
+#include "BVHPageNode.hxx"
+#include "BVHPageRequest.hxx"
+
+namespace simgear {
+
+struct BVHPager::_PrivateData : protected SGThread {
+    typedef SGSharedPtr<BVHPageRequest> _Request;
+    typedef std::list<_Request> _RequestList;
+    typedef std::list<SGSharedPtr<BVHPageNode> > _PageNodeList;
+    
+    struct _LockedQueue {
+        void _push(const _Request& request)
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            _requestList.push_back(request);
+        }
+        _Request _pop()
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            if (_requestList.empty())
+                return _Request();
+            _Request request;
+            request.swap(_requestList.front());
+            _requestList.pop_front();
+            return request;
+        }
+    private:
+        SGMutex _mutex;
+        _RequestList _requestList;
+    };
+    
+    struct _WorkQueue {
+        void _stop()
+        {
+            _push(_Request());
+        }
+        void _push(const _Request& request)
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            bool needSignal = _requestList.empty();
+            _requestList.push_back(request);
+            if (needSignal)
+                _waitCondition.signal();
+        }
+        _Request _pop()
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            while (_requestList.empty())
+                _waitCondition.wait(_mutex);
+            _Request request;
+            request.swap(_requestList.front());
+            _requestList.pop_front();
+            return request;
+        }
+    private:
+        SGMutex _mutex;
+        SGWaitCondition _waitCondition;
+        _RequestList _requestList;
+    };
+
+    _PrivateData() :
+        _started(false),
+        _useStamp(0)
+    {
+    }
+    virtual ~_PrivateData()
+    {
+        _stop();
+    }
+
+    virtual void run()
+    {
+        for (;;) {
+            _Request request = _pendingRequests._pop();
+            // This means stop working
+            if (!request.valid())
+                return;
+            request->load();
+            _processedRequests._push(request);
+        }
+    }
+
+    bool _start()
+    {
+        if (_started)
+            return true;
+        if (!start())
+            return false;
+        _started = true;
+        return true;
+    }
+    
+    void _stop()
+    {
+        if (!_started)
+            return;
+        // send a stop request ...
+        _pendingRequests._stop();
+        // ... and wait for the thread to finish
+        join();
+        _started = false;
+    }
+
+    void _use(BVHPageNode& pageNode)
+    {
+        if (pageNode._requested) {
+            // move it forward in the lru list
+            _pageNodeList.splice(_pageNodeList.end(), _pageNodeList,
+                                 pageNode._iterator);
+        } else {
+            _Request request = pageNode.newRequest();
+            if (!request.valid())
+                return;
+
+            pageNode._iterator = _pageNodeList.insert(_pageNodeList.end(),
+                                                      &pageNode);
+            pageNode._requested = true;
+
+            if (_started) {
+                _pendingRequests._push(request);
+            } else {
+                request->load();
+                request->insert();
+            }
+        }
+        pageNode._useStamp = _useStamp;
+    }
+
+    void _update(unsigned expiry)
+    {
+        // Insert all processed requests
+        for (;;) {
+            SGSharedPtr<BVHPageRequest> request;
+            request = _processedRequests._pop();
+            if (!request.valid())
+                break;
+            request->insert();
+        }
+
+        // ... and throw away stuff that is not used for a long time
+        unsigned useStamp = _useStamp - expiry;
+        _PageNodeList::iterator i = _pageNodeList.begin();
+        while (i != _pageNodeList.end()) {
+            // Ok, this means if the highest bit in the below difference
+            // is set which is aequivalent to having a negative difference
+            // but being wraparound save.
+            unsigned diff = (*i)->_useStamp - useStamp;
+            // test the sign bit of the difference
+            if (!(diff & (~((~0u) >> 1))))
+                break;
+            (*i)->clear();
+            (*i)->_requested = false;
+            i = _pageNodeList.erase(i);
+        }
+    }
+
+    bool _started;
+    unsigned _useStamp;
+    _WorkQueue _pendingRequests;
+    _LockedQueue _processedRequests;
+    // Store the rcu list of loaded nodes so that they can expire
+    _PageNodeList _pageNodeList;
+};
+
+BVHPager::BVHPager() :
+    _privateData(new _PrivateData)
+{
+}
+
+BVHPager::~BVHPager()
+{
+    delete _privateData;
+    _privateData = 0;
+}
+
+bool
+BVHPager::start()
+{
+    return _privateData->_start();
+}
+
+void
+BVHPager::stop()
+{
+    _privateData->_stop();
+}
+
+void
+BVHPager::use(BVHPageNode& pageNode)
+{
+    _privateData->_use(pageNode);
+}
+
+void
+BVHPager::update(unsigned expiry)
+{
+    _privateData->_update(expiry);
+}
+
+void
+BVHPager::setUseStamp(unsigned stamp)
+{
+    _privateData->_useStamp = stamp;
+}
+
+unsigned
+BVHPager::getUseStamp() const
+{
+    return _privateData->_useStamp;
+}
+
+}

simgear/bvh/BVHPager.hxx

@@ -0,0 +1,60 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHPager_hxx
+#define BVHPager_hxx
+
+#include <simgear/structure/SGSharedPtr.hxx>
+
+namespace simgear {
+
+class BVHPageNode;
+class BVHPageRequest;
+
+class BVHPager {
+public:
+    BVHPager();
+    ~BVHPager();
+
+    /// Starts the pager thread
+    bool start();
+
+    /// Stops the pager thread
+    void stop();
+
+    /// Use this page node, if loaded make it as used, if not loaded schedule
+    void use(BVHPageNode& pageNode);
+
+    /// Call this from the main thread to incorporate the processed page
+    /// requests into the bounding volume tree
+    void update(unsigned expiry);
+
+    /// The usage stamp to mark usage of BVHPageNodes
+    void setUseStamp(unsigned stamp);
+    unsigned getUseStamp() const;
+
+private:
+    BVHPager(const BVHPager&);
+    BVHPager& operator=(const BVHPager&);
+
+    struct _PrivateData;
+    _PrivateData* _privateData;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticBinary.cxx

@@ -0,0 +1,45 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHStaticBinary.hxx"
+
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+BVHStaticBinary::BVHStaticBinary(unsigned splitAxis,
+                                   const BVHStaticNode* leftChild,
+                                   const BVHStaticNode* rightChild,
+                                   const SGBoxf& boundingBox) :
+  _splitAxis(splitAxis),
+  _leftChild(leftChild),
+  _rightChild(rightChild),
+  _boundingBox(boundingBox)
+{
+}
+
+BVHStaticBinary::~BVHStaticBinary()
+{
+}
+
+void
+BVHStaticBinary::accept(BVHVisitor& visitor, const BVHStaticData& data) const
+{
+  visitor.apply(*this, data);
+}
+
+}

simgear/bvh/BVHStaticBinary.hxx

@@ -0,0 +1,78 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHStaticBinary_hxx
+#define BVHStaticBinary_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "BVHStaticNode.hxx"
+
+namespace simgear {
+
+class BVHStaticBinary : public BVHStaticNode {
+public:
+  BVHStaticBinary(unsigned splitAxis, const BVHStaticNode* leftChild,
+                   const BVHStaticNode* rightChild, const SGBoxf& box);
+  virtual ~BVHStaticBinary();
+  virtual void accept(BVHVisitor& visitor, const BVHStaticData& data) const;
+
+  void traverse(BVHVisitor& visitor, const BVHStaticData& data) const
+  {
+    _leftChild->accept(visitor, data);
+    _rightChild->accept(visitor, data);
+  }
+
+  // Traverse call that first enters the child node that is potentially closer
+  // to the given point than the other.
+  template<typename T>
+  void traverse(BVHVisitor& visitor, const BVHStaticData& data,
+                const SGVec3<T>& pt) const
+  {
+    float center = 0.5f*(_boundingBox.getMin()[_splitAxis]
+                         + _boundingBox.getMax()[_splitAxis]);
+    if (pt[_splitAxis] < center) {
+      _leftChild->accept(visitor, data);
+      _rightChild->accept(visitor, data);
+    } else {
+      _rightChild->accept(visitor, data);
+      _leftChild->accept(visitor, data);
+    }
+  }
+
+  unsigned getSplitAxis() const
+  { return _splitAxis; }
+
+  const BVHStaticNode* getLeftChild() const
+  { return _leftChild; }
+  const BVHStaticNode* getRightChild() const
+  { return _rightChild; }
+
+  const SGBoxf& getBoundingBox() const
+  { return _boundingBox; }
+
+private:
+  // Note the order of the members, this is to avoid padding
+  unsigned _splitAxis;
+  SGSharedPtr<const BVHStaticNode> _leftChild;
+  SGSharedPtr<const BVHStaticNode> _rightChild;
+  SGBoxf _boundingBox;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticData.hxx

@@ -0,0 +1,57 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHStaticData_hxx
+#define BVHStaticData_hxx
+
+#include <vector>
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/math/SGGeometry.hxx>
+#include "BVHMaterial.hxx"
+
+namespace simgear {
+
+class BVHStaticData : public SGReferenced {
+public:
+    virtual ~BVHStaticData() {}
+    
+    unsigned addVertex(const SGVec3f& vertex)
+    { _vertices.push_back(vertex); return _vertices.size() - 1; }
+    const SGVec3f& getVertex(unsigned i) const
+    { return _vertices[i]; }
+    
+    
+    unsigned addMaterial(const BVHMaterial* material)
+    { _materials.push_back(material); return _materials.size() - 1; }
+    const BVHMaterial* getMaterial(unsigned i) const
+    { if (_materials.size() <= i) return 0; return _materials[i]; }
+
+    void trim()
+    {
+        std::vector<SGVec3f>(_vertices).swap(_vertices);
+        std::vector<SGSharedPtr<const BVHMaterial> >(_materials).swap(_materials);
+    }
+    
+private:
+    std::vector<SGVec3f> _vertices;
+    std::vector<SGSharedPtr<const BVHMaterial> > _materials;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticGeometry.cxx

@@ -0,0 +1,51 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 "BVHStaticGeometry.hxx"
+
+#include "BVHBoundingBoxVisitor.hxx"
+
+namespace simgear {
+
+BVHStaticGeometry::BVHStaticGeometry(const BVHStaticNode* staticNode,
+                                     const BVHStaticData* staticData) :
+    _staticNode(staticNode),
+    _staticData(staticData)
+{
+}
+
+BVHStaticGeometry::~BVHStaticGeometry()
+{
+}
+
+void
+BVHStaticGeometry::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+SGSphered
+BVHStaticGeometry::computeBoundingSphere() const
+{
+    BVHBoundingBoxVisitor bbv;
+    _staticNode->accept(bbv, *_staticData);
+    SGSphered sphere;
+    sphere.expandBy(SGBoxd(bbv.getBox()));
+    return sphere;
+}
+
+}

simgear/bvh/BVHStaticGeometry.hxx

@@ -0,0 +1,56 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHStaticGeometry_hxx
+#define BVHStaticGeometry_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHStaticData.hxx"
+#include "BVHStaticNode.hxx"
+
+namespace simgear {
+
+class BVHStaticGeometry : public BVHNode {
+public:
+    BVHStaticGeometry(const BVHStaticNode* staticNode,
+                      const BVHStaticData* staticData);
+    virtual ~BVHStaticGeometry();
+    
+    virtual void accept(BVHVisitor& visitor);
+    
+    void traverse(BVHVisitor& visitor) const
+    { _staticNode->accept(visitor, *_staticData); }
+    
+    const BVHStaticData* getStaticData() const
+    { return _staticData; }
+    const BVHStaticNode* getStaticNode() const
+    { return _staticNode; }
+    
+    virtual SGSphered computeBoundingSphere() const;
+    
+private:
+    SGSharedPtr<const BVHStaticNode> _staticNode;
+    SGSharedPtr<const BVHStaticData> _staticData;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticGeometryBuilder.hxx

@@ -0,0 +1,228 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// 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 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 BVHStaticGeometryBuilder_hxx
+#define BVHStaticGeometryBuilder_hxx
+
+#include <algorithm>
+#include <map>
+#include <set>
+
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHTransform.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticLeaf.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+#include "BVHStaticGeometry.hxx"
+
+namespace simgear {
+
+class BVHStaticGeometryBuilder : public SGReferenced {
+public:
+    BVHStaticGeometryBuilder() :
+        _staticData(new BVHStaticData),
+        _currentMaterial(0),
+        _currentMaterialIndex(~0u)
+    { }
+    virtual ~BVHStaticGeometryBuilder()
+    { }
+
+    struct LeafRef {
+        LeafRef(const BVHStaticLeaf* leaf, const BVHStaticData& data) :
+            _leaf(leaf),
+            _box(_leaf->computeBoundingBox(data)),
+            _center(_leaf->computeCenter(data))
+        { }
+        SGSharedPtr<const BVHStaticLeaf> _leaf;
+        SGBoxf _box;
+        SGVec3f _center;
+    };
+    typedef std::list<LeafRef> LeafRefList;
+
+    struct LeafRefLess : public std::binary_function<LeafRef, LeafRef, bool> {
+        LeafRefLess(unsigned sortAxis) : _sortAxis(sortAxis) {}
+        bool operator()(const LeafRef& x, const LeafRef& y)
+        { return x._center[_sortAxis] < y._center[_sortAxis]; }
+        unsigned _sortAxis;
+    };
+
+    SGSharedPtr<BVHStaticData> _staticData;
+    LeafRefList _leafRefList;
+
+    typedef std::map<SGVec3f, unsigned> VertexMap;
+    VertexMap _vertexMap;
+
+    typedef std::set<SGVec3<unsigned> > TriangleSet;
+    TriangleSet _triangleSet;
+
+    void setCurrentMaterial(const BVHMaterial* material)
+    {
+        _currentMaterial = material;
+        _currentMaterialIndex = addMaterial(material);
+    }
+    const BVHMaterial* getCurrentMaterial() const
+    {
+        return _currentMaterial;
+    }
+    unsigned addMaterial(const BVHMaterial* material)
+    {
+        MaterialMap::const_iterator i = _materialMap.find(material);
+        if (i != _materialMap.end())
+            return i->second;
+        unsigned index = _staticData->addMaterial(material);
+        _materialMap[material] = index;
+        return index;
+    }
+
+    typedef std::map<const BVHMaterial*, unsigned> MaterialMap;
+    MaterialMap _materialMap;
+    const BVHMaterial* _currentMaterial;
+    unsigned _currentMaterialIndex;
+
+    void addTriangle(const SGVec3f& v1, const SGVec3f& v2, const SGVec3f& v3)
+    {
+        unsigned indices[3] = { addVertex(v1), addVertex(v2), addVertex(v3) };
+        std::sort(indices, indices + 3);
+        SGVec3<unsigned> indexKey(indices);
+        if (_triangleSet.find(indexKey) != _triangleSet.end())
+            return;
+        _triangleSet.insert(indexKey);
+        BVHStaticTriangle* staticTriangle;
+        staticTriangle = new BVHStaticTriangle(_currentMaterialIndex, indices);
+        _leafRefList.push_back(LeafRef(staticTriangle, *_staticData));
+    }
+    unsigned addVertex(const SGVec3f& v)
+    {
+        VertexMap::const_iterator i = _vertexMap.find(v);
+        if (i != _vertexMap.end())
+            return i->second;
+        unsigned index = _staticData->addVertex(v);
+        _vertexMap[v] = index;
+        return index;
+    }
+
+    BVHStaticGeometry* buildTree()
+    {
+        const BVHStaticNode* tree = buildTreeRecursive(_leafRefList);
+        if (!tree)
+            return 0;
+        _staticData->trim();
+        return new BVHStaticGeometry(tree, _staticData);
+    }
+
+private:
+    static void
+    centerSplitLeafs(unsigned splitAxis, const double& splitValue,
+                     LeafRefList& leafs, LeafRefList split[2])
+    {
+        while (!leafs.empty()) {
+            if (leafs.front()._center[splitAxis] < splitValue) {
+                split[0].splice(split[0].begin(), leafs, leafs.begin());
+            } else {
+                split[1].splice(split[1].begin(), leafs, leafs.begin());
+            }
+        }
+    }
+
+    static void
+    equalSplitLeafs(unsigned splitAxis, LeafRefList& leafs,
+                    LeafRefList split[2])
+    {
+        leafs.sort(LeafRefLess(splitAxis));
+        while (true) {
+            if (leafs.empty())
+                break;
+            split[0].splice(split[0].begin(), leafs, leafs.begin());
+            
+            if (leafs.empty())
+                break;
+            split[1].splice(split[1].begin(), leafs, --leafs.end());
+        }
+    }
+    
+    static const BVHStaticNode* buildTreeRecursive(LeafRefList& leafs)
+    {
+        // recursion termination
+        if (leafs.empty())
+            return 0;
+        // FIXME size is O(n)!!!
+        //   if (leafs.size() == 1)
+        if (++leafs.begin() == leafs.end())
+            return leafs.front()._leaf;
+        
+        SGBoxf box;
+        for (LeafRefList::const_iterator i = leafs.begin();
+             i != leafs.end(); ++i)
+            box.expandBy(i->_box);
+        
+        //   // FIXME ...
+        //   if (length(box.getSize()) < 1)
+        //     return new BVHBox(box);
+        
+        if (box.empty())
+            return 0;
+        
+        unsigned splitAxis = box.getBroadestAxis();
+        LeafRefList splitLeafs[2];
+        double splitValue = box.getCenter()[splitAxis];
+        centerSplitLeafs(splitAxis, splitValue, leafs, splitLeafs);
+        
+        if (splitLeafs[0].empty() || splitLeafs[1].empty()) {
+            for (unsigned i = 0; i < 3 ; ++i) {
+                if (i == splitAxis)
+                    continue;
+                
+                leafs.swap(splitLeafs[0]);
+                leafs.splice(leafs.begin(), splitLeafs[1]);
+                splitValue = box.getCenter()[i];
+                centerSplitLeafs(i, splitValue, leafs, splitLeafs);
+                
+                if (!splitLeafs[0].empty() && !splitLeafs[1].empty()) {
+                    splitAxis = i;
+                    break;
+                }
+            }
+        }
+        if (splitLeafs[0].empty() || splitLeafs[1].empty()) {
+            leafs.swap(splitLeafs[0]);
+            leafs.splice(leafs.begin(), splitLeafs[1]);
+            equalSplitLeafs(splitAxis, leafs, splitLeafs);
+        }
+        
+        const BVHStaticNode* child0 = buildTreeRecursive(splitLeafs[0]);
+        const BVHStaticNode* child1 = buildTreeRecursive(splitLeafs[1]);
+        if (!child0)
+            return child1;
+        if (!child1)
+            return child0;
+        
+        return new BVHStaticBinary(splitAxis, child0, child1, box);
+    }
+};
+
+}
+
+#endif