#658: avoid crash when Textures.high is missing

Don't resolve the empty file name, which would result in the fgdata
directory path (instead of a path to a file). Eventually this resulted in
a segfault, partly due to a bug in "osgDB::readImageFile", which reports
"success" when given a directory (instead of a file) path, though it
doesn't return a valid image object.

.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
+INSTALL
+SimGear.spec
+*.o
+lib*.a
+.*.swp
+cmake_install.cmake
+CMakeFiles
+CMakeCache.txt
+CPackConfig.cmake
+CPackSourceConfig.cmake
+cmake_uninstall.cmake
+CTestTestfile.cmake
+install_manifest.txt
+build
+Build

CMakeLists.txt

@@ -0,0 +1,267 @@
+cmake_minimum_required (VERSION 2.6.4)
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckCXXSourceCompiles)
+
+
+project(SimGear)
+
+# read 'version' file into a variable (stripping any newlines or spaces)
+file(READ version versionFile)
+string(STRIP ${versionFile} SIMGEAR_VERSION)
+
+# use simgear version also as the SO version (if building SOs)
+SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})
+
+#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}")
+
+option(SIMGEAR_SHARED "Set to ON to build SimGear as a shared library/framework" OFF)
+option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
+option(JPEG_FACTORY "Enable JPEG-factory support" OFF)
+option(ENABLE_LIBSVN "Set to ON to build SimGear with libsvnclient support" ON)
+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)
+
+if (MSVC)
+  GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_SOURCE_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 1600)
+      set( OSG_MSVC ${OSG_MSVC}100 )
+  else (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}90 )
+  endif (${MSVC_VERSION} EQUAL 1600)
+  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 )
+  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include)
+  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 (ALUT_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)
+
+find_package(Boost REQUIRED)
+set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
+
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
+
+if(SIMGEAR_HEADLESS)
+    message(STATUS "headless mode")
+    set(NO_OPENSCENEGRAPH_INTERFACE 1)
+else()
+    find_package(OpenGL REQUIRED)
+    find_package(OpenAL REQUIRED)
+    find_package(ALUT REQUIRED)
+    find_package(OpenSceneGraph 3.0.0 REQUIRED osgText osgSim osgDB osgParticle osgUtil)
+endif(SIMGEAR_HEADLESS)
+
+if(JPEG_FACTORY)
+    message(STATUS "JPEG-factory enabled")
+    find_package(JPEG REQUIRED)
+    include_directories(${JPEG_INCLUDE_DIR})
+endif(JPEG_FACTORY)
+
+if(ENABLE_LIBSVN)
+	find_package(SvnClient)
+
+	if(LIBSVN_FOUND)
+		message(STATUS "libsvn found, enabling in SimGear")
+		set(HAVE_SVN_CLIENT_H 1)
+		set(HAVE_LIBSVN_CLIENT_1 1)
+	else()
+		message(STATUS "Missing libsvn, unable to enable SVN in SimGear")
+	endif(LIBSVN_FOUND)
+endif(ENABLE_LIBSVN)
+
+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(ENABLE_RTI)
+# See if we have any rti library variant installed
+    find_package(RTI)
+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)
+
+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_function_exists(clock_gettime CLOCK_GETTIME_IN_LIBC)
+    if(NOT CLOCK_GETTIME_IN_LIBC)
+        check_library_exists(rt clock_gettime "" HAVE_RT)
+        if(HAVE_RT)
+            set(RT_LIBRARY rt)
+        endif(HAVE_RT)
+        endif(NOT CLOCK_GETTIME_IN_LIBC)
+endif(HAVE_CLOCK_GETTIME)
+
+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)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    set(WARNING_FLAGS -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(WIN32)
+
+    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")
+    endif(MSVC)
+    
+    # assumed on Windows
+    set(HAVE_GETLOCALTIME 1)
+    
+    set( WINSOCK_LIBRARY "ws2_32.lib" )
+    set( RT_LIBRARY "winmm" )
+endif(WIN32)    
+
+if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") 
+   set (WARNING_FLAGS "-Wall -Wno-overloaded-virtual")
+endif() 
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
+
+include_directories(${PROJECT_SOURCE_DIR})
+include_directories(${PROJECT_BINARY_DIR}/simgear)
+
+include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
+    ${Boost_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIR} 
+    ${ALUT_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
+
+include (Dart)
+enable_testing()
+endif(ENABLE_TESTS)
+
+install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
+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/FindALUT.cmake

@@ -0,0 +1,67 @@
+# Locate ALUT
+# This module defines
+# ALUT_LIBRARY
+# ALUT_FOUND, if false, do not try to link to ALUT 
+# ALUT_INCLUDE_DIR, where to find the headers
+#
+# $ALUTDIR is an environment variable that would
+# correspond to the ./configure --prefix=$ALUTDIR
+# used in building ALUT.
+#
+# Created by James Turner. This was influenced by the FindOpenAL.cmake module.
+
+#=============================================================================
+# Copyright 2005-2009 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 distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Per my request, CMake should search for frameworks first in
+# the following order:
+# ~/Library/Frameworks/OpenAL.framework/Headers
+# /Library/Frameworks/OpenAL.framework/Headers
+# /System/Library/Frameworks/OpenAL.framework/Headers
+#
+# On OS X, this will prefer the Framework version (if found) over others.
+# People will have to manually change the cache values of 
+# OPENAL_LIBRARY to override this selection or set the CMake environment
+# CMAKE_INCLUDE_PATH to modify the search paths.
+
+FIND_PATH(ALUT_INCLUDE_DIR alut.h
+  HINTS
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES include/AL include/ALUT include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+FIND_LIBRARY(ALUT_LIBRARY 
+  NAMES ALUT alut
+  HINTS
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+
+SET(ALUT_FOUND "NO")
+IF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+  SET(ALUT_FOUND "YES")
+ENDIF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+

CMakeModules/FindSvnClient.cmake

@@ -0,0 +1,76 @@
+# Find Subversion client libraries, and dependencies
+# including APR (Apache Portable Runtime)
+
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckLibraryExists)
+
+macro(find_static_component comp libs)
+    # account for alternative Windows svn distribution naming
+    if(MSVC)
+      set(compLib "lib${comp}")
+    else(MSVC)
+      set(compLib "${comp}")
+    endif(MSVC)
+    
+    string(TOUPPER "${comp}" compLibBase)
+    set( compLibName ${compLibBase}_LIBRARY )
+
+    FIND_LIBRARY(${compLibName}
+      NAMES ${compLib}
+      HINTS $ENV{PLIBDIR}
+      PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
+      PATHS
+      /usr/local
+      /usr
+      /opt
+    )
+
+	list(APPEND ${libs} ${${compLibName}})
+endmacro()
+
+find_program(HAVE_APR_CONFIG apr-1-config)
+if(HAVE_APR_CONFIG) 
+        
+    execute_process(COMMAND apr-1-config --cppflags --includes
+        OUTPUT_VARIABLE APR_CFLAGS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+        
+    execute_process(COMMAND apr-1-config --link-ld
+        OUTPUT_VARIABLE RAW_APR_LIBS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    
+# clean up some vars, or other CMake pieces complain
+	string(STRIP "${RAW_APR_LIBS}" APR_LIBS)
+
+else(HAVE_APR_CONFIG)
+    message(STATUS "apr-1-config not found, implement manual search for APR")
+endif(HAVE_APR_CONFIG)
+
+if(HAVE_APR_CONFIG OR MSVC)
+	find_path(LIBSVN_INCLUDE_DIR svn_client.h
+	  HINTS
+	  $ENV{LIBSVN_DIR}
+	  PATH_SUFFIXES include/subversion-1
+	  PATHS
+	  /usr/local
+	  /usr
+	  /opt
+	)
+	
+	set(LIBSVN_LIBRARIES "")
+	if (MSVC)
+		find_static_component("apr-1" LIBSVN_LIBRARIES)
+	else (MSVC)
+		list(APPEND LIBSVN_LIBRARIES ${APR_LIBS})
+	endif (MSVC)
+	find_static_component("svn_client-1" LIBSVN_LIBRARIES)
+	find_static_component("svn_subr-1" LIBSVN_LIBRARIES)
+	find_static_component("svn_ra-1" LIBSVN_LIBRARIES)
+
+	include(FindPackageHandleStandardArgs)
+	FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG LIBSVN_LIBRARIES LIBSVN_INCLUDE_DIR)
+        if(NOT LIBSVN_FOUND)
+		set(LIBSVN_LIBRARIES "")
+        endif(NOT LIBSVN_FOUND)
+endif(HAVE_APR_CONFIG OR MSVC)

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,31 @@
+
+macro(simgear_component_common name includePath sourcesList sources headers)
+    if (SIMGEAR_SHARED)
+
+        foreach(s ${sources})
+            set_property(GLOBAL
+                APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+        endforeach()
+
+		foreach(h ${headers})
+			set_property(GLOBAL
+				APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+		endforeach()
+        
+    else()
+        set(libName "sg${name}")
+        add_library(${libName} STATIC ${sources} ${headers})
+
+        install (TARGETS ${libName} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
+    
+    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()

Doxyfile

@@ -22,7 +22,7 @@ PROJECT_NAME           = SimGear
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.3.10
+PROJECT_NUMBER         = 2.2.0
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 

Makefile.am

@@ -1,22 +0,0 @@
-EXTRA_DIST = \
-	acinclude.m4 \
-	autogen.sh \
-	DoxygenMain.cxx \
-	README.MSVC \
-	README.zlib \
-	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
-

NEWS

@@ -1,3 +1,15 @@
+Version 1.9.0
+* Thu Dec 18 15:12:15 CST 2008
+
+
+Version 1.8.6
+* Mon Dec  1 14:02:47 CST 2008
+
+
+Version 1.8.5
+* October 30, 2008 (source code snapshot release)
+
+
 New in 0.3.10
 * April 5, 2006
 

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

@@ -0,0 +1,26 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+You *must* have OpenSceneGraph (OSG) installed to build this version of
+FlightGear.
+
+Notice that FlightGear 2.6.0 requires at least version 3.0.0.
+
+You can get the latest version of OSG from:
+
+http://www.openscenegraph.org/
+
+Build notes:
+
+Unzip the file OpenSceneGraph-x.x.zip and install using the following
+commands:
+
+unzip OpenSceneGraph-x.x
+cd OpenSceneGraph
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+make
+sudo make install
+

README.OpenAL

@@ -3,10 +3,27 @@
 You *must* have the development components of OpenAL installed on your system
 to build FlightGear!"  You can get a copy here:
 
-    http://www.openal.org
+      http://connect.creativelabs.com/openal/default.aspx
 
 Build notes:
 
-The OpenAL developers do not make "versioned" releases so we recommend that
-you pull the latest version via anonymous CVS (follow the instructions at
-the OpenAL web site) and build/install that.
+You can download a versioned release of the openal library from 
+http://www.openal.org/downloads.html. Download the openal source,
+release 0.0.8 (dated February 11, 2006) and run:  
+tar xjvf openal-soft-1.5.304.tar.bz2
+cd openal-soft-1.5.304/
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+
+The alut library is also required, but comes separately in the package
+freelut-1.1.0.tar.gz. This package can be downloaded from the same page
+(http://connect.creativelabs.com/openal/default.aspx). Download and run:
+tar xzvf freelut-1.1.0.tar.gz
+cd freealut-1.1.0
+./configure
+make
+sudo make install
+

README.plib

@@ -1,6 +1,6 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 
-You *must* have plib version 1.6.0 or later installed on your system
+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.
 
@@ -14,3 +14,19 @@ 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>
-{{{
-}}}
-
-###############################################################################
-

Thanks

@@ -120,7 +120,7 @@ Petter Reinholdtsen <pere@games.no>
   Incorporated the Gnu automake/autoconf system (with libtool).
   This should streamline and standardize the build process for all
   Unix-like platforms.  It should have little effect on IDE type 
-  environments since the don't use the Unix make system.
+  environments since these don't use the Unix make system.
 
 
 Paul Schlyter <pausch@saaf.se>  

acinclude.m4

@@ -1,415 +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])

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,479 +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, 0.3.10)
-
-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
-])
-
-echo CXX = $CXX
-echo CC = $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
-
-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"
-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"
-    ;;
-
-*-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"
-    ;;
-
-*)
-    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"
-    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
-
-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.4 or newer])
-AC_TRY_RUN([
-#include <plib/ul.h>
-
-#define MIN_PLIB_VERSION 184
-
-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.4 or later first...])],
-  AC_MSG_RESULT(yes)
-)
-
-LIBS="$saved_LIBS"
-
-AC_LANG_POP
-
-dnl Check for system installed zlib
-AC_CHECK_HEADER(zlib.h)
-if test "x$ac_cv_header_zlib_h" != "xyes"; then
-    echo
-    echo "zlib 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
-

projects/VC100/README

@@ -0,0 +1,2 @@
+The handmade VS2010 project files have been replaced by the Cmake build system.
+Please use Cmake to build FlightGear with Visual Studio 2010.

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

projects/VC90/.gitignore

@@ -0,0 +1,3 @@
+*.user
+Win32
+x64

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,3 @@
+simgear_config.h
+simgear_config.h.*
+version.h

simgear/CMakeLists.txt

@@ -0,0 +1,98 @@
+
+file(WRITE ${PROJECT_BINARY_DIR}/simgear/version.h "#define SIMGEAR_VERSION ${SIMGEAR_VERSION}")
+
+foreach( mylibfolder 
+        bucket
+        debug
+        ephemeris
+        io
+        magvar
+        math
+        misc
+        nasal
+        props
+        route
+        serial
+        structure
+        threads
+        timing
+        xml
+    )
+
+    add_subdirectory(${mylibfolder})
+
+endforeach( mylibfolder )
+
+if(NOT SIMGEAR_HEADLESS)
+    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/)
+
+if(SIMGEAR_SHARED)
+    message(STATUS "building shared library")
+    get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
+    get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
+    get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
+
+    add_library(SimGearCore SHARED ${coreSources})
+    set_property(TARGET SimGearCore PROPERTY COMPILE_FLAGS "-DNO_OPENSCENEGRAPH_INTERFACE=1")
+    
+  # set_property(TARGET SimGearCore PROPERTY FRAMEWORK 1)
+  #  message(STATUS "public header: ${publicHeaders}")
+  #  set_property(TARGET SimGearCore PROPERTY PUBLIC_HEADER "${publicHeaders}")
+    set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
+
+    set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
+    set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+
+    target_link_libraries(SimGearCore ${ZLIB_LIBRARY} ${RT_LIBRARY})
+    install(TARGETS SimGearCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+    if(NOT SIMGEAR_HEADLESS)
+        if(LIBSVN_FOUND)
+            add_definitions(${APR_CFLAGS})
+
+            IF(APPLE)
+                set_property(SOURCE scene/tsync/terrasync.cxx PROPERTY COMPILE_FLAGS "-iwithsysroot ${LIBSVN_INCLUDE_DIR}")
+            ELSE()
+                include_directories(${LIBSVN_INCLUDE_DIR})
+            ENDIF(APPLE)
+        endif(LIBSVN_FOUND)
+        
+        list(APPEND sceneSources scene/util/SGCoreOSGDependant.cxx)
+        
+        add_library(SimGearScene SHARED ${sceneSources})
+      # set_property(TARGET SimGearScene PROPERTY FRAMEWORK 1)
+      # set_property(TARGET SimGearScene PROPERTY PUBLIC_HEADER "${publicHeaders}")
+        set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
+        set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
+        set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+    
+        target_link_libraries(SimGearScene 
+            SimGearCore
+            ${ZLIB_LIBRARY} 
+            ${OPENSCENEGRAPH_LIBRARIES} 
+            ${OPENAL_LIBRARY} ${ALUT_LIBRARY}
+            ${OPENGL_LIBRARY}
+            ${JPEG_LIBRARY})
+    
+        if(LIBSVN_FOUND)
+            target_link_libraries(SimGearScene ${LIBSVN_LIBRARIES})
+        endif(LIBSVN_FOUND)
+
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
+   
+endif(SIMGEAR_SHARED)
+    

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 sg_traits.hxx 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,7 @@
+
+include (SimGearComponent)
+
+set(HEADERS newbucket.hxx)
+set(SOURCES newbucket.cxx)
+
+simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")

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 = \
-# 	$(top_builddir)/bucket/libsgbucket.a \
-# 	$(top_builddir)/misc/libsgmisc.a
-
-INCLUDES = -I$(top_srcdir)

simgear/bucket/newbucket.cxx

@@ -92,6 +92,11 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
 
     // cout << "diff = " << diff << "  span = " << span << endl;
 
+    /* Calculate the greatest integral longitude less than
+     * or equal to the given longitude (floor(dlon)),
+     * but attribute coordinates near the east border
+     * to the next tile.
+     */
     if ( (dlon >= 0) || (fabs(diff) < SG_EPSILON) ) {
 	lon = (int)dlon;
     } else {
@@ -100,22 +105,48 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
 
     // find subdivision or super lon if needed
     if ( span < SG_EPSILON ) {
+        /* sg_bucket_span() never returns 0.0
+         * or anything near it, so this really
+         * should not occur at any time.
+         */
 	// polar cap
 	lon = 0;
 	x = 0;
     } else if ( span <= 1.0 ) {
+        /* We have more than one tile per degree of
+         * longitude, so we need an x offset.
+         */
 	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;
-	    }
-	}
+        /* 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.
+         *
+         * This gets us into trouble with the polar caps,
+         * which have width 360 and thus either span
+         * the range from 0 to 360 or from -360 to 0
+         * degrees, depending on whether lon is positive
+         * or negative!
+         *
+         * We also get into trouble with the 8 degree tiles
+         * north of 88N and south of 88S, because the west-
+         * and east-most tiles in that range will cover 184W
+         * to 176W and 176E to 184E respectively, with their
+         * center at 180E/W!
+         */
+        lon=(int)floor(floor((lon+SG_EPSILON)/span)*span);
+        /* Correct the polar cap issue */
+        if ( lon < -180 ) {
+            lon = -180;
+        }
 	x = 0;
     }
 
@@ -124,11 +155,15 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
     //
     diff = dlat - (double)(int)dlat;
 
+    /* Again, a modified floor() function (see longitude) */
     if ( (dlat >= 0) || (fabs(diff) < SG_EPSILON) ) {
 	lat = (int)dlat;
     } else {
 	lat = (int)dlat - 1;
     }
+    /* Latitude base and offset are easier, as
+     * tiles always are 1/8 degree of latitude wide.
+     */
     y = (int)((dlat - lat) * 8);
 }
 
@@ -139,7 +174,7 @@ void SGBucket::set_bucket(const SGGeod& geod)
 }
 
 // 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;
@@ -189,6 +224,17 @@ string SGBucket::gen_base_path() const {
 
 // return width of the tile in degrees
 double SGBucket::get_width() const {
+    if (lon==-180 && (lat==-89 || lat==88) ) {
+        /* Normally the tile at 180W in 88N and 89S
+         * would cover 184W to 176W and the next
+         * on the east side starts at 176W.
+         * To correct, make this a special tile
+         * from 180W to 176W with 4 degrees width
+         * instead of the normal 8 degrees at
+         * that latitude.
+         */
+         return 4.0;
+    }
     return sg_bucket_span( get_center_lat() );
 }
 
@@ -213,7 +259,7 @@ double SGBucket::get_width_m() const {
     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;
 }
 
 

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
@@ -33,29 +38,10 @@
 #include <simgear/constants.h>
 #include <simgear/math/SGMath.hxx>
 
-#ifdef SG_HAVE_STD_INCLUDES
-#  include <cmath>
-#  include <cstdio> // sprintf()
-#else
-#  include <math.h>
-#  include <stdio.h> // sprintf()
-#endif
-
-#include STL_IOSTREAM
-
-// I don't understand ... <math.h> or <cmath> should be included
-// already depending on how you defined SG_HAVE_STD_INCLUDES, but I
-// can go ahead and add this -- CLO
-#ifdef __MWERKS__
-SG_USING_STD(sprintf);
-SG_USING_STD(fabs);
-#endif
-
-#include STL_STRING
-
-SG_USING_STD(string);
-SG_USING_STD(ostream);
-
+#include <cmath>
+#include <cstdio> // sprintf()
+#include <ostream>
+#include <string>
 
 /**
  * standard size of a bucket in degrees (1/8 of a degree)
@@ -114,7 +100,6 @@ 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)
@@ -210,18 +195,19 @@ public:
      * string form.
      * @return tile index in string form
      */
-    inline string gen_index_str() const {
+    inline std::string gen_index_str() const {
 	char tmp[20];
-	sprintf(tmp, "%ld", 
-                (((long)lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x);
-	return (string)tmp;
+	std::sprintf(tmp, "%ld", 
+                     (((long)lon + 180) << 14) + ((lat + 90) << 6)
+                     + (y << 3) + x);
+	return (std::string)tmp;
     }
 
     /**
      * Build the base path name for this bucket.
      * @return base path in string form
      */
-    string gen_base_path() const;
+    std::string gen_base_path() const;
 
     /**
      * @return the center lon of a tile.
@@ -230,9 +216,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;
 	}
     }
 
@@ -306,10 +292,15 @@ public:
 
     // friends
 
-    friend ostream& operator<< ( ostream&, const SGBucket& );
+    friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
     friend bool operator== ( const SGBucket&, const SGBucket& );
 };
 
+inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
 
 /**
  * \relates SGBucket
@@ -340,10 +331,10 @@ void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy );
  * @param out output stream
  * @param b bucket
  */
-inline ostream&
-operator<< ( ostream& out, const SGBucket& b )
+inline std::ostream&
+operator<< ( std::ostream& out, const SGBucket& b )
 {
-    return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
+    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
 }
 
 

simgear/compatibility/.cvsignore

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

simgear/compatibility/MIPSpro721/.cvsignore

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

simgear/compatibility/MIPSpro721/Makefile.am

@@ -1,14 +0,0 @@
-includedir = @includedir@/compatibility/
-
-include_HEADERS	= \
-	iostream \
-	strstream \
-	sstream \
-	istream \
-	fstream \
-	iterator \
-	iomanip \
-	new \
-	streambuf \
-	\
-	irix_string

simgear/compatibility/MIPSpro740/.cvsignore

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

simgear/compatibility/MIPSpro740/Makefile.am

@@ -1,22 +0,0 @@
-includedir = @includedir@/compatibility
-
-EXTRA_DIST = README
-
-include_HEADERS	= \
-	cfloat \
-	csetjmp \
-	cstdio \
-	cwchar \
-	cassert \
-	climits \
-	csignal \
-	cstdlib \
-	cwctype \
-	cctype \
-	clocale \
-	cstdarg \
-	cstring \
-	cerrno \
-	cmath \
-	cstddef \
-	ctime

simgear/compatibility/Makefile.am

@@ -1,3 +0,0 @@
-SUBDIRS = $(MIPSpro_DIRS)
-
-DIST_SUBDIRS = MIPSpro721 MIPSpro740

simgear/compiler.h

@@ -23,48 +23,9 @@
  * A set of defines to encapsulate compiler and platform differences.
  * Please refer to the source code for full documentation on this file.
  *
- * Here is a summary of what this file does.
+ * This file is useful to set compiler-specific options in every file - for
+ * example, disabling warnings.
  *
- *  (1)  Defines macros for some STL includes which may be affected
- *       by file name length limitations.
- *
- *  (2)  Defines macros for some features not supported by all C++ compilers.
- *
- *  (3)  Defines 'explicit' as a null macro if the compiler doesn't support
- *       the explicit keyword.
- *
- *  (4)  Defines 'typename' as a null macro if the compiler doesn't support
- *       the typename keyword.
- *
- *  (5)  Defines bool, true and false if the compiler doesn't do so.
- *
- *  (6)  Defines SG_EXPLICIT_FUNCTION_TMPL_ARGS if the compiler
- *       supports calling a function template by providing its template
- *       arguments explicitly.
- *
- *  (7)  Defines SG_NEED_AUTO_PTR if STL doesn't provide auto_ptr<>.
- *
- *  (8)  Defines SG_NO_ARROW_OPERATOR if the compiler is unable
- *       to support operator->() for iterators.
- *
- *  (9)  Defines SG_USE_EXCEPTIONS if the compiler supports exceptions.
- *       Note: no FlightGear code uses exceptions.
- *
- *  (10) Define SG_NAMESPACES if the compiler supports namespaces.
- *
- *  (11) SG_MATH_FN_IN_NAMESPACE_STD -- not used??
- *
- *  (12) Define SG_HAVE_STD if std namespace is supported.
- *
- *  (13) Defines SG_CLASS_PARTIAL_SPECIALIZATION if the compiler 
- *       supports partial specialization of class templates.
- *
- *  (14) Defines SG_HAVE_STD_INCLUDES to use ISO C++ Standard headers.
- *
- *  (15) Defines SG_HAVE_STREAMBUF if <streambuf> of <streambuf.h> are present.
- *
- *  (16) Define SG_MATH_EXCEPTION_CLASH if math.h defines an exception class
- *       that clashes with the one defined in <stdexcept>.
  */
 
 #ifndef _SG_COMPILER_H
@@ -79,158 +40,37 @@
 #define SG_DO_STRINGIZE(X) #X
 
 #ifdef __GNUC__
-#  if __GNUC__ == 2 
-#    if __GNUC_MINOR__ < 8
-
-       // g++-2.7.x
-#      define STL_ALGORITHM  <algorithm>
-#      define STL_FUNCTIONAL <functional>
-#      define STL_IOMANIP    <iomanip.h>
-#      define STL_IOSTREAM   <iostream.h>
-#      define STL_ITERATOR   <iterator.h>
-#      define STL_FSTREAM    <fstream.h>
-#      define STL_STDEXCEPT  <stdexcept>
-#      define STL_STRING     <string>
-#      define STL_STRSTREAM  <strstream.h>
-
-#      define SG_NEED_AUTO_PTR
-#      define SG_NO_DEFAULT_TEMPLATE_ARGS
-#      define SG_INCOMPLETE_FUNCTIONAL
-#      define SG_NO_ARROW_OPERATOR
-
-#    elif __GNUC_MINOR__ >= 8
-
-       // g++-2.8.x and egcs-1.x
-#      define SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#      define SG_NEED_AUTO_PTR
-#      define SG_MEMBER_TEMPLATES
-#      define SG_NAMESPACES
-#      define SG_HAVE_STD
-#      define SG_HAVE_STREAMBUF
-#      define SG_CLASS_PARTIAL_SPECIALIZATION
-
-#      define STL_ALGORITHM  <algorithm>
-#      define STL_FUNCTIONAL <functional>
-#      define STL_IOMANIP    <iomanip>
-#      define STL_IOSTREAM   <iostream>
-#      define STL_ITERATOR   <iterator>
-#      define STL_FSTREAM    <fstream>
-#      define STL_STDEXCEPT  <stdexcept>
-#      define STL_STRING     <string>
-#      define STL_STRSTREAM  <strstream>
-
-#    endif
-#  elif __GNUC__ >= 3
-       // g++-3.0.x
-#      define SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#      define SG_NEED_AUTO_PTR
-#      define SG_MEMBER_TEMPLATES
-#      define SG_NAMESPACES
-#      define SG_HAVE_STD
-#      define SG_HAVE_STREAMBUF
-#      define SG_CLASS_PARTIAL_SPECIALIZATION
-#      define SG_HAVE_STD_INCLUDES
-
-#      define STL_ALGORITHM  <algorithm>
-#      define STL_FUNCTIONAL <functional>
-#      define STL_IOMANIP    <iomanip>
-#      define STL_IOSTREAM   <iostream>
-#      define STL_ITERATOR   <iterator>
-#      define STL_FSTREAM    <fstream>
-#      define STL_STDEXCEPT  <stdexcept>
-#      define STL_STRING     <string>
-#      define STL_STRSTREAM  <strstream>
-#  else
-#    error Time to upgrade. GNU compilers < 2.7 not supported
+#  if __GNUC__ < 3
+#    error Time to upgrade. GNU compilers < 3.0 not supported
+#  elif (__GNUC__ == 3) && (__GNUC_MINOR__ < 4)
+#    warning GCC compilers prior to 3.4 are suspect  
 #  endif
 
 #  define SG_COMPILER_STR "GNU C++ version " SG_STRINGIZE(__GNUC__) "." SG_STRINGIZE(__GNUC_MINOR__)
-
 #endif // __GNUC__
 
 /* KAI C++ */
 #if defined(__KCC)
-
-#  define SG_NAMESPACES
-#  define SG_HAVE_STD
-#  define SG_HAVE_STREAMBUF
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRING     <string>
-#  define STL_STRSTREAM  <strstream>
-
 #  define SG_COMPILER_STR "Kai C++ version " SG_STRINGIZE(__KCC_VERSION)
-
 #endif // __KCC
 
-//
-// Metrowerks 
-//
-#if defined(__MWERKS__)
-/*
-  CodeWarrior compiler from Metrowerks, Inc.
-*/
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-#  define SG_HAVE_STD
-#  define SG_NAMESPACES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRING     <string>
-
-// Temp:
-#  define bcopy(from, to, n) memcpy(to, from, n)
-
-// -rp- please use FG_MEM_COPY everywhere !
-// #define FG_MEM_COPY(to,from,n) memcpy(to, from, n)
-
-// -dw- currently used glut has no game mode stuff
-#  define GLUT_WRONG_VERSION
-
-#  define SG_COMPILER_STR "Metrowerks CodeWarrior C++ version " SG_STRINGIZE(__MWERKS__)
-
-#endif // __MWERKS__
-
 //
 // Microsoft compilers.
 //
 #ifdef _MSC_VER
 #  define bcopy(from, to, n) memcpy(to, from, n)
-#  define FG_MEM_COPY(to,from,n) memcpy(to, from, n)
 
 #  if _MSC_VER >= 1200  // msvc++ 6.0 or greater
-#    define SG_NAMESPACES
-#    define SG_HAVE_STD
-#    define SG_HAVE_STD_INCLUDES
-#    define SG_HAVE_STREAMBUF
-
-#    define STL_ALGORITHM  <algorithm>
-#    define STL_FUNCTIONAL <functional>
-#    define STL_IOMANIP    <iomanip>
-#    define STL_IOSTREAM   <iostream>
-#    define STL_ITERATOR   <iterator>
-#    define STL_FSTREAM    <fstream>
-#    define STL_STDEXCEPT  <stdexcept>
-#    define STL_STRING     <string>
-#    define STL_STRSTREAM  <strstream>
-
 #    define isnan _isnan
 #    define snprintf _snprintf
+#    if _MSC_VER < 1500
+#      define vsnprintf _vsnprintf
+#    endif
 #    define copysign _copysign
+#    define strcasecmp stricmp
+
+#    undef min
+#    undef max
 
 #    pragma warning(disable: 4786) // identifier was truncated to '255' characters
 #    pragma warning(disable: 4244) // conversion from double to float
@@ -244,79 +84,23 @@
 
 #endif // _MSC_VER
 
-#ifdef __BORLANDC__
-# if defined(HAVE_SGI_STL_PORT)
-
-// Use quotes around long file names to get around Borland's include hackery
-
-#  define STL_ALGORITHM  "algorithm"
-#  define STL_FUNCTIONAL "functional"
-
-#  define SG_MATH_EXCEPTION_CLASH
-
-# else
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRSTREAM  <strstream>
-
-#  define SG_INCOMPLETE_FUNCTIONAL
-
-# endif // HAVE_SGI_STL_PORT
-
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STRING     <string>
-#  define SG_NO_DEFAULT_TEMPLATE_ARGS
-#  define SG_NAMESPACES
-// #  define SG_HAVE_STD
-
-#  define SG_COMPILER_STR "Borland C++ version " SG_STRINGIZE(__BORLANDC__)
-
-#endif // __BORLANDC__
-
 //
 // Native SGI compilers
 //
 
 #if defined ( sgi ) && !defined( __GNUC__ )
-#  define SG_HAVE_NATIVE_SGI_COMPILERS
+# if (_COMPILER_VERSION < 740)
+#  error Need MipsPro 7.4.0 or higher now
+# endif
 
-#  define SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#  define SG_CLASS_PARTIAL_SPECIALIZATION
-#  define SG_NEED_AUTO_PTR
-#  define SG_MEMBER_TEMPLATES
-#  define SG_NAMESPACES
-#  define SG_HAVE_STD
-#  define SG_HAVE_STREAMBUF
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#if (_COMPILER_VERSION < 740)
-#  define STL_STRING     <irix_string>
-#else
-#  define STL_STRING     <string>
-#endif
-#  define STL_STRSTREAM  <strstream>
+#define SG_HAVE_NATIVE_SGI_COMPILERS
 
 #pragma set woff 1001,1012,1014,1116,1155,1172,1174
 #pragma set woff 1401,1460,1551,1552,1681
 
 #ifdef __cplusplus
-#pragma set woff 1682,3303
-#if (_COMPILER_VERSION >= 740)
-#  pragma set woff 3624
-#endif
+# pragma set woff 1682,3303
+# pragma set woff 3624
 #endif
 
 #  define SG_COMPILER_STR "SGI MipsPro compiler version " SG_STRINGIZE(_COMPILER_VERSION)
@@ -325,6 +109,7 @@
 
 
 #if defined (__sun)
+#  define SG_UNIX
 #  include <strings.h>
 #  include <memory.h>
 #  if defined ( __cplusplus )
@@ -346,24 +131,7 @@
 // Intel C++ Compiler
 //
 #if defined(__ICC) || defined (__ECC)
-#  define SG_NAMESPACES
-#  define SG_HAVE_STD
-#  define SG_HAVE_STREAMBUF
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRING     <string>
-#  define STL_STRSTREAM  <strstream>
-
 #  define SG_COMPILER_STR "Intel C++ version " SG_STRINGIZE(__ICC)
-
 #endif // __ICC
 
 //
@@ -371,101 +139,51 @@
 //
 
 #ifdef __APPLE__
-#  define SG_GL_H <OpenGL/gl.h>
-#  define SG_GLX_H <AGL/agl.h>
-#  define SG_GLU_H <OpenGL/glu.h>
-#  define SG_GLEXT_H <OpenGL/glext.h>
-#  define SG_GLUT_H <GLUT/glut.h>
-
+#  define SG_MAC
+#  define SG_UNIX
+#  ifdef __GNUC__
+#    if ( __GNUC__ > 3 ) || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 3 )
 inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
-#else
-#  define SG_GL_H <GL/gl.h>
-#  define SG_GLX_H <GL/glx.h>
-#  define SG_GLU_H <GL/glu.h>
-#  define SG_GLEXT_H <GL/glext.h>
-#  define SG_GLUT_H <GL/glut.h>
+#    else
+    // any C++ header file undefines isinf and isnan
+    // so this should be included before <iostream>
+    // the functions are STILL in libm (libSystem on mac os x)
+extern "C" int (isnan)(double);
+extern "C" int (isinf)(double);
+#    endif
+#  else
+inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
+#  endif
 #endif
 
+#if defined (__FreeBSD__)
+#  define SG_UNIX
+#include <sys/param.h>
+#  if __FreeBSD_version < 500000
+     extern "C" {
+       inline int isnan(double r) { return !(r <= 0 || r >= 0); }
+     }
+#  endif
+#endif
+
+#if defined (__CYGWIN__)
+#  define SG_WINDOWS
+#  define SG_UNIX
+#  include <ieeefp.h>		// isnan
+#endif
+
+// includes both MSVC and mingw compilers
+#if defined(_WIN32) || defined(__WIN32__)
+#  define SG_WINDOWS
+#endif
+
+#if defined(__linux__) || defined(_AIX) || defined ( sgi )
+#  define SG_UNIX
+#endif
 
 //
 // No user modifiable definitions beyond here.
 //
 
-#ifdef SG_NEED_EXPLICIT
-#  define explicit
-#endif
-
-#ifdef SG_NEED_TYPENAME
-#  define typename
-#endif
-
-#ifdef SG_NEED_MUTABLE
-#  define mutable
-#endif
-
-#ifdef SG_NEED_BOOL
-   typedef int bool;
-#  define true 1
-#  define false 0
-#endif
-
-#ifdef SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#  define SG_NULL_TMPL_ARGS <>
-#else
-#  define SG_NULL_TMPL_ARGS
-#endif
-
-#ifdef SG_CLASS_PARTIAL_SPECIALIZATION
-# define SG_TEMPLATE_NULL template<>
-#else
-# define SG_TEMPLATE_NULL
-#endif
-
-// SG_NO_NAMESPACES is a hook so that users can disable namespaces
-// without having to edit library headers.
-#if defined(SG_NAMESPACES) && !defined(SG_NO_NAMESPACES)
-#   define SG_NAMESPACE(X) namespace X {
-#   define SG_NAMESPACE_END }
-#   define SG_USING_NAMESPACE(X) using namespace X
-# else
-#   define SG_NAMESPACE(X)
-#   define SG_NAMESPACE_END
-#   define SG_USING_NAMESPACE(X)
-#endif
-
-/** \def SG_USING_STD(x)
- *  Expands to using std::x if SG_HAVE_STD is defined 
- */
-# ifdef SG_HAVE_STD
-#  define SG_USING_STD(X) using std::X
-#  define STD std
-# else
-#  define SG_USING_STD(X) 
-#  define STD
-# endif
-
-// Additional <functional> implementation from SGI STL 3.11
-// Adapter function objects: pointers to member functions
-#ifdef SG_INCOMPLETE_FUNCTIONAL
-
-template <class _Ret, class _Tp>
-class const_mem_fun_ref_t
-#ifndef __BORLANDC__
-    : public unary_function<_Tp,_Ret>
-#endif // __BORLANDC__
-{
-public:
-  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
-  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
-private:
-  _Ret (_Tp::*_M_f)() const;
-};
-
-template <class _Ret, class _Tp>
-inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
-  { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
-
-#endif // SG_INCOMPLETE_FUNCTIONAL
-
 #endif // _SG_COMPILER_H
 

simgear/constants.h

@@ -31,24 +31,25 @@
 
 #include <simgear/compiler.h>
 
-#ifdef SG_HAVE_STD_INCLUDES
-#  include <cmath>
-#else
-#  ifdef SG_MATH_EXCEPTION_CLASH
-#    define exception C_exception
-#  endif
-#  include <math.h>
-#endif
-
-#include <plib/sg.h>
+#include <cmath>
 
 
 // Make sure PI is defined in its various forms
 
-// SG_PI and SGD_PI (float and double) come from plib/sg.h
+#ifndef SGD_PI // remove me once FlightGear no longer uses PLIB
+
+#ifdef M_PI
+const double SGD_PI = M_PI;
+const float SG_PI = M_PI;
+#else
+const float SG_PI = 3.1415926535f;
+const double SGD_PI = 3.1415926535;
+#endif
+
+#endif // of PLIB-SG guard
 
 /** 2 * PI */
-#define SGD_2PI      6.28318530717958647692
+const double SGD_2PI = SGD_PI * 2.0;
 
 /** PI / 2 */
 #ifdef M_PI_2
@@ -58,7 +59,17 @@
 #endif
 
 /** PI / 4 */
-#define SGD_PI_4     0.78539816339744830961
+const double SGD_PI_4 = 0.78539816339744830961;
+
+#ifndef SGD_DEGREES_TO_RADIANS // // remove me once FlightGear no longer uses PLIB
+
+const double SGD_DEGREES_TO_RADIANS = SGD_PI / 180.0;
+const double SGD_RADIANS_TO_DEGREES = 180.0 / SGD_PI;
+
+const float SG_DEGREES_TO_RADIANS = SG_PI / 180.0f;
+const float SG_RADIANS_TO_DEGREES = 180.0f / SG_PI;
+
+#endif // of PLIB-SG guard
 
 /** \def SG_E "e" */
 #ifdef M_E
@@ -75,6 +86,8 @@
  *  6378.165 but this is probably close enough */
 #define SG_EARTH_RAD 6378.155
 
+// Maximum terrain elevation from sea level
+#define SG_MAX_ELEVATION_M 9000.0
 
 // Earth parameters for WGS 84, taken from LaRCsim/ls_constants.h
 
@@ -122,10 +135,10 @@
 /** Nautical Miles to Radians */
 #define SG_RAD_TO_NM        3437.7467707849392526
 
-/** Miles per second to Knots */
+/** meters per second to Knots */
 #define SG_MPS_TO_KT        1.9438444924406046432
 
-/** Knots to Miles per second */
+/** Knots to meters per second */
 #define SG_KT_TO_MPS        0.5144444444444444444
 
 /** Feet per second to Knots */
@@ -134,16 +147,16 @@
 /** Knots to Feet per second */
 #define SG_KT_TO_FPS        1.6878098571011956874
 
-/** Miles per second to Miles per hour */
+/** meters per second to Miles per hour */
 #define SG_MPS_TO_MPH       2.2369362920544020312
 
-/** Miles per hour to Miles per second */
+/** meetrs per hour to Miles per second */
 #define SG_MPH_TO_MPS       0.44704
 
 /** Meters per second to Kilometers per hour */
 #define SG_MPS_TO_KMH       3.6
 
-/** Kilometers per hour to Miles per second */
+/** Kilometers per hour to meters per second */
 #define SG_KMH_TO_MPS       0.2777777777777777778
 
 /** Pascal to Inch Mercury */

simgear/debug/.cvsignore

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

simgear/debug/CMakeLists.txt

@@ -0,0 +1,7 @@
+
+include (SimGearComponent)
+
+set(HEADERS debug_types.h logstream.hxx)
+set(SOURCES logstream.cxx)
+
+simgear_component(debug debug "${SOURCES}" "${HEADERS}")

simgear/debug/Makefile.am

@@ -1,11 +0,0 @@
-includedir = @includedir@/debug
-
-EXTRA_DIST = logtest.cxx
-
-lib_LIBRARIES = libsgdebug.a
-
-include_HEADERS = debug_types.h logstream.hxx
-
-libsgdebug_a_SOURCES = logstream.cxx
-
-INCLUDES = -I$(top_srcdir)

simgear/debug/debug_types.h

@@ -1,35 +1,38 @@
 /** \file debug_types.h
- *  Define the various logging classes and prioritiess
+ *  Define the various logging classes and priorities
  */
 
 /** 
  * Define the possible classes/categories of logging messages
  */
 typedef enum {
-    SG_NONE      = 0x00000000,
+    SG_NONE        = 0x00000000,
 
-    SG_TERRAIN   = 0x00000001,
-    SG_ASTRO     = 0x00000002,
-    SG_FLIGHT    = 0x00000004,
-    SG_INPUT     = 0x00000008,
-    SG_GL        = 0x00000010,
-    SG_VIEW      = 0x00000020,
-    SG_COCKPIT   = 0x00000040,
-    SG_GENERAL   = 0x00000080,
-    SG_MATH      = 0x00000100,
-    SG_EVENT     = 0x00000200,
-    SG_AIRCRAFT  = 0x00000400,
-    SG_AUTOPILOT = 0x00000800,
-    SG_IO        = 0x00001000,
-    SG_CLIPPER   = 0x00002000,
-    SG_NETWORK   = 0x00004000,
-    SG_ATC       = 0x00008000,
-    SG_NASAL     = 0x00010000,
-    SG_INSTR     = 0x00020000,
-    SG_SYSTEMS   = 0x00040000,
-    SG_UNDEFD    = 0x00080000, // For range checking
+    SG_TERRAIN     = 0x00000001,
+    SG_ASTRO       = 0x00000002,
+    SG_FLIGHT      = 0x00000004,
+    SG_INPUT       = 0x00000008,
+    SG_GL          = 0x00000010,
+    SG_VIEW        = 0x00000020,
+    SG_COCKPIT     = 0x00000040,
+    SG_GENERAL     = 0x00000080,
+    SG_MATH        = 0x00000100,
+    SG_EVENT       = 0x00000200,
+    SG_AIRCRAFT    = 0x00000400,
+    SG_AUTOPILOT   = 0x00000800,
+    SG_IO          = 0x00001000,
+    SG_CLIPPER     = 0x00002000,
+    SG_NETWORK     = 0x00004000,
+    SG_ATC         = 0x00008000,
+    SG_NASAL       = 0x00010000,
+    SG_INSTR       = 0x00020000,
+    SG_SYSTEMS     = 0x00040000,
+    SG_AI          = 0x00080000,
+    SG_ENVIRONMENT = 0x00100000,
+    SG_SOUND       = 0x00200000,
+    SG_UNDEFD      = 0x00400000, // For range checking
 
-    SG_ALL     = 0xFFFFFFFF
+    SG_ALL         = 0xFFFFFFFF
 } sgDebugClass;
 
 

simgear/debug/logstream.cxx

@@ -20,18 +20,31 @@
 //
 // $Id$
 
+#include <iostream>
+
 #include "logstream.hxx"
 
-logstream *global_logstream = NULL;
+logstream *logstream::global_logstream = 0;
 
 bool            logbuf::logging_enabled = true;
-#ifdef _MSC_VER
+#ifdef _WIN32
    bool         logbuf::has_console = true;
 #endif
 sgDebugClass    logbuf::logClass        = SG_NONE;
 sgDebugPriority logbuf::logPriority     = SG_INFO;
 streambuf*      logbuf::sbuf            = NULL;
 
+namespace {
+struct ignore_me
+{
+    ignore_me()
+    {
+        logstream::initGlobalLogstream();
+    }
+};
+static ignore_me im;
+}
+
 logbuf::logbuf()
 {
 //     if ( sbuf == NULL )
@@ -90,3 +103,12 @@ logstream::setLogLevels( sgDebugClass c, sgDebugPriority p )
     logbuf::set_log_level( c, p );
 }
 
+logstream *
+logstream::initGlobalLogstream()
+{
+    // Force initialization of cerr.
+    static std::ios_base::Init initializer;
+    if( !global_logstream )
+        global_logstream = new logstream(std::cerr);
+    return global_logstream;
+}

simgear/debug/logstream.hxx

@@ -27,29 +27,18 @@
 
 #include <simgear/compiler.h>
 
-#ifdef _MSC_VER
+#ifdef _WIN32
 #  include <windows.h>
 #endif
 
-#ifdef SG_HAVE_STD_INCLUDES
-# include <streambuf>
-# include <iostream>
-#else
-# include <iostream.h>
-# include <simgear/sg_traits.hxx>
-#endif
+#include <streambuf>
+#include <ostream>
+#include <cstdio>
 
 #include <simgear/debug/debug_types.h>
 
-SG_USING_STD(streambuf);
-SG_USING_STD(ostream);
-SG_USING_STD(cout);
-SG_USING_STD(cerr);
-SG_USING_STD(endl);
-
-#ifdef __MWERKS__
-SG_USING_STD(iostream);
-#endif
+using std::streambuf;
+using std::ostream;
 
 //
 // TODO:
@@ -67,17 +56,10 @@ SG_USING_STD(iostream);
 #ifdef SG_NEED_STREAMBUF_HACK
 class logbuf : public __streambuf
 #else
-class logbuf : public streambuf
+class logbuf : public std::streambuf
 #endif
 {
 public:
-
-#ifndef SG_HAVE_STD_INCLUDES
-    typedef char_traits<char>           traits_type;
-    typedef char_traits<char>::int_type int_type;
-    // typedef char_traits<char>::pos_type pos_type;
-    // typedef char_traits<char>::off_type off_type;
-#endif
     // logbuf( streambuf* sb ) : sbuf(sb) {}
     /** Constructor */
     logbuf();
@@ -97,6 +79,8 @@ public:
      */
     void set_log_state( sgDebugClass c, sgDebugPriority p );
 
+    bool would_log( sgDebugClass c, sgDebugPriority p ) const;
+
     /**
      * Set the global logging level.
      * @param c debug class
@@ -137,9 +121,9 @@ public:
      * Set the stream buffer
      * @param sb stream buffer
      */
-    void set_sb( streambuf* sb );
+    void set_sb( std::streambuf* sb );
 
-#ifdef _MSC_VER
+#ifdef _WIN32
     static void has_no_console() { has_console = false; }
 #endif
 
@@ -155,10 +139,10 @@ protected:
 private:
 
     // The streambuf used for actual output. Defaults to cerr.rdbuf().
-    static streambuf* sbuf;
+    static std::streambuf* sbuf;
 
     static bool logging_enabled;
-#ifdef _MSC_VER
+#ifdef _WIN32
     static bool has_console;
 #endif
     static sgDebugClass logClass;
@@ -174,11 +158,7 @@ private:
 inline int
 logbuf::sync()
 {
-#ifdef SG_HAVE_STD_INCLUDES
 	return sbuf->pubsync();
-#else
-	return sbuf->sync();
-#endif
 }
 
 inline void
@@ -187,10 +167,16 @@ logbuf::set_log_state( sgDebugClass c, sgDebugPriority p )
     logging_enabled = ((c & logClass) != 0 && p >= logPriority);
 }
 
+inline bool
+logbuf::would_log( sgDebugClass c, sgDebugPriority p ) const
+{
+    return ((c & logClass) != 0 && p >= logPriority);
+}
+
 inline logbuf::int_type
 logbuf::overflow( int c )
 {
-#ifdef _MSC_VER
+#ifdef _WIN32
     if ( logging_enabled ) {
         if ( !has_console ) {
             AllocConsole();
@@ -238,23 +224,23 @@ struct logstream_base
 /**
  * Class to manage the debug logging stream.
  */
-class logstream : private logstream_base, public ostream
+class logstream : private logstream_base, public std::ostream
 {
 public:
     /**
      * The default is to send messages to cerr.
      * @param out output stream
      */
-    logstream( ostream& out )
+    logstream( std::ostream& out )
 	// : logstream_base(out.rdbuf()),
 	: logstream_base(),
-	  ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
+	  std::ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
 
     /**
      * Set the output stream
      * @param out output stream
      */
-    void set_output( ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
+    void set_output( std::ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
 
     /**
      * Set the global log class and priority level.
@@ -263,22 +249,29 @@ public:
      */
     void setLogLevels( sgDebugClass c, sgDebugPriority p );
 
+    bool would_log(  sgDebugClass c, sgDebugPriority p ) const
+    {
+        return lbuf.would_log( c, p );
+    };
+
     /**
      * Output operator to capture the debug level and priority of a message.
      * @param l log level
      */
-    inline ostream& operator<< ( const loglevel& l );
+    inline std::ostream& operator<< ( const loglevel& l );
+    friend logstream& sglog();
+    static logstream *initGlobalLogstream();
+protected:
+    static logstream *global_logstream;
 };
 
-inline ostream&
+inline std::ostream&
 logstream::operator<< ( const loglevel& l )
 {
     lbuf.set_log_state( l.logClass, l.logPriority );
     return *this;
 }
 
-extern logstream *global_logstream;
-
 /**
  * \relates logstream
  * Return the one and only logstream instance.
@@ -289,22 +282,7 @@ extern logstream *global_logstream;
 inline logstream&
 sglog()
 {
-  if (global_logstream == NULL) {
-
-#ifdef __APPLE__
-    /**
-     * There appears to be a bug in the C++ runtime in Mac OS X that
-     * will crash if certain funtions are called (in this case
-     * cerr.rdbuf()) during static initialization of a class. This
-     * print statement is hack to kick the library in the pants so it
-     * won't crash when cerr.rdbuf() is first called -DW 
-     **/
-    cout << "Using Mac OS X hack for initializing C++ stdio..." << endl;
-#endif    
-    global_logstream = new logstream (cerr);
-  }
-    
-  return *global_logstream;
+    return *logstream::initGlobalLogstream();
 }
 
 
@@ -316,12 +294,15 @@ sglog()
  */
 #ifdef FG_NDEBUG
 # define SG_LOG(C,P,M)
-#elif defined( __MWERKS__ )
-# define SG_LOG(C,P,M) ::sglog() << ::loglevel(C,P) << M << std::endl
 #else
-# define SG_LOG(C,P,M) sglog() << loglevel(C,P) << M << endl
+# define SG_LOG(C,P,M) do {                     \
+	logstream& __tmplogstreamref(sglog());                      \
+	if(__tmplogstreamref.would_log(C,P)) {                      \
+        __tmplogstreamref << loglevel(C,P) << M << std::endl; } \
+	} while(0)
 #endif
 
+#define SG_ORIGIN __FILE__ ":" SG_STRINGIZE(__LINE__)
 
 #endif // _LOGSTREAM_H
 

simgear/debug/logtest.cxx

@@ -1,5 +1,5 @@
 #include <string>
-#include "Debug/logstream.hxx"
+#include <simgear/debug/logstream.hxx>
 
 class Test {
 

simgear/environment/.cvsignore

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

simgear/environment/CMakeLists.txt

@@ -0,0 +1,23 @@
+
+include (SimGearComponent)
+
+set(HEADERS metar.hxx precipitation.hxx)
+set(SOURCES metar.cxx precipitation.cxx)
+
+simgear_scene_component(environment environment "${SOURCES}" "${HEADERS}")
+
+if(ENABLE_TESTS)
+add_executable(test_metar test_metar.cxx)
+
+if (SIMGEAR_SHARED)
+    target_link_libraries(test_metar SimGearScene) 
+else()
+    target_link_libraries(test_metar
+        sgenvironment sgstructure sgmisc sgdebug
+        ${CMAKE_THREAD_LIBS_INIT}
+        ${ZLIB_LIBRARY}
+        ${RT_LIBRARY})
+endif()
+
+add_test(metar ${EXECUTABLE_OUTPUT_PATH}/test_metar)
+endif(ENABLE_TESTS)

simgear/environment/Makefile.am

@@ -1,9 +0,0 @@
-includedir = @includedir@/environment
-
-lib_LIBRARIES = libsgenvironment.a
-
-include_HEADERS = metar.hxx visual_enviro.hxx
-
-libsgenvironment_a_SOURCES = metar.cxx visual_enviro.cxx
-
-INCLUDES = -I$(top_srcdir)

simgear/environment/metar.cxx

@@ -30,8 +30,8 @@
 
 #include <string>
 #include <time.h>
+#include <cstring>
 
-#include <simgear/io/sg_socket.hxx>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/structure/exception.hxx>
 
@@ -39,32 +39,28 @@
 
 #define NaN SGMetarNaN
 
+using std::string;
+using std::map;
+using std::vector;
+
 /**
- * The constructor takes a Metar string, or a four-letter ICAO code. In the
- * latter case the metar string is downloaded from
- * http://weather.noaa.gov/pub/data/observations/metar/stations/.
+ * The constructor takes a Metar string
  * The constructor throws sg_io_exceptions on failure. The "METAR"
  * keyword has no effect (apart from incrementing the group counter
  * @a grpcount) and can be left away. A keyword "SPECI" is
  * likewise accepted.
  *
  * @param m     ICAO station id or metar string
- * @param proxy proxy host (optional; default: "")
- * @param port  proxy port (optional; default: "80")
- * @param auth  proxy authorization information (optional; default: "")
  *
  * @par Examples:
  * @code
  * SGMetar *m = new SGMetar("METAR KSFO 061656Z 19004KT 9SM SCT100 OVC200 08/03 A3013");
  * double t = m->getTemperature_F();
  * delete m;
- *
- * SGMetar n("KSFO", "proxy.provider.foo", "3128", "proxy-password");
- * double d = n.getDewpoint_C();
+
  * @endcode
  */
-SGMetar::SGMetar(const string& m, const string& proxy, const string& port,
-		const string& auth, const time_t time) :
+SGMetar::SGMetar(const string& m) :
 	_grpcount(0),
 	_x_proxy(false),
 	_year(-1),
@@ -86,16 +82,10 @@ SGMetar::SGMetar(const string& m, const string& proxy, const string& port,
 	_snow(false),
 	_cavok(false)
 {
-	if (m.length() == 4 && isalnum(m[0]) && isalnum(m[1]) && isalnum(m[2]) && isalnum(m[3])) {
-		for (int i = 0; i < 4; i++)
-			_icao[i] = toupper(m[i]);
-		_icao[4] = '\0';
-		_data = loadData(_icao, proxy, port, auth, time);
-	} else {
-		_data = new char[m.length() + 2];	// make room for " \0"
-		strcpy(_data, m.c_str());
-		_url = _data;
-	}
+	_data = new char[m.length() + 2];	// make room for " \0"
+	strcpy(_data, m.c_str());
+	_url = _data;
+		
 	normalizeData();
 
 	_m = _data;
@@ -159,7 +149,7 @@ void SGMetar::useCurrentDate()
 {
 	struct tm now;
 	time_t now_sec = time(0);
-#if defined( _MSC_VER ) || defined ( __MINGW32__ )
+#ifdef _WIN32
 	now = *gmtime(&now_sec);
 #else
 	gmtime_r(&now_sec, &now);
@@ -168,83 +158,6 @@ void SGMetar::useCurrentDate()
 	_month = now.tm_mon + 1;
 }
 
-
-/**
-  * If called with "KSFO" loads data from
-  * @code
-  * http://weather.noaa.gov/pub/data/observations/metar/stations/KSFO.TXT.
-  * @endcode
-  * Throws sg_io_exception on failure. Gives up after waiting longer than 10 seconds.
-  *
-  * @param id four-letter ICAO Metar station code, e.g. "KSFO".
-  * @param proxy proxy host (optional; default: "")
-  * @param port  proxy port (optional; default: "80")
-  * @param auth  proxy authorization information (optional; default: "")
-  * @return pointer to Metar data string, allocated by new char[].
-  * @see rfc2068.txt for proxy spec ("Proxy-Authorization")
-  */
-char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
-		const string& auth, time_t time)
-{
-	const int buflen = 512;
-	char buf[2 * buflen];
-
-	string host = proxy.empty() ? "weather.noaa.gov" : proxy;
-	string path = "/pub/data/observations/metar/stations/";
-
-	path += string(id) + ".TXT";
-	_url = "http://weather.noaa.gov" + path;
-
-	SGSocket *sock = new SGSocket(host, port.empty() ? "80" : port, "tcp");
-	sock->set_timeout(10000);
-	if (!sock->open(SG_IO_OUT)) {
-		delete sock;
-		throw sg_io_exception("cannot connect to ", sg_location(host));
-	}
-
-	string get = "GET ";
-	if (!proxy.empty())
-		get += "http://weather.noaa.gov";
-
-	sprintf(buf, "%ld", time);
-	get += path + " HTTP/1.0\015\012X-Time: " + buf + "\015\012";
-
-	if (!auth.empty())
-		get += "Proxy-Authorization: " + auth + "\015\012";
-
-	get += "\015\012";
-	sock->writestring(get.c_str());
-
-	int i;
-
-	// skip HTTP header
-	while ((i = sock->readline(buf, buflen))) {
-		if (i <= 2 && isspace(buf[0]) && (!buf[1] || isspace(buf[1])))
-			break;
-		if (!strncmp(buf, "X-MetarProxy: ", 13))
-			_x_proxy = true;
-	}
-	if (i) {
-		i = sock->readline(buf, buflen);
-		if (i)
-			sock->readline(&buf[i], buflen);
-	}
-
-	sock->close();
-	delete sock;
-
-	char *b = buf;
-	scanBoundary(&b);
-	if (*b == '<')
-		throw sg_io_exception("no metar data available from ", 
-				sg_location(_url));
-
-	char *metar = new char[strlen(b) + 2];	// make room for " \0"
-	strcpy(metar, b);
-	return metar;
-}
-
-
 /**
   * Replace any number of subsequent spaces by just one space, and add
   * a trailing space. This makes scanning for things like "ALL RWY" easier.
@@ -465,11 +378,13 @@ bool SGMetar::scanVisibility()
 	int modifier = SGMetarVisibility::EQUALS;
 // \d{4}(N|NE|E|SE|S|SW|W|NW)?
 	if (scanNumber(&m, &i, 4)) {
-		if (*m == 'E')
+		if( strncmp( m, "NDV",3 ) == 0 ) {
+			m+=3; // tolerate NDV (no directional validation)
+		} else if (*m == 'E') {
 			m++, dir = 90;
-		else if (*m == 'W')
+		} else if (*m == 'W') {
 			m++, dir = 270;
-		else if (*m == 'N') {
+		} else if (*m == 'N') {
 			m++;
 			if (*m == 'E')
 				m++, dir = 45;
@@ -485,7 +400,7 @@ bool SGMetar::scanVisibility()
 				m++, dir = 225;
 			else
 				dir = 180;
-		}
+                }
 		if (i == 0)
 			i = 50, modifier = SGMetarVisibility::LESS_THAN;
 		else if (i == 9999)
@@ -493,7 +408,6 @@ bool SGMetar::scanVisibility()
 		distance = i;
 	} else {
 // M?(\d{1,2}|\d{1,2}/\d{1,2}|\d{1,2} \d{1,2}/\d{1,2})(SM|KM)
-		modifier = 0;
 		if (*m == 'M')
 			m++, modifier = SGMetarVisibility::LESS_THAN;
 
@@ -592,7 +506,7 @@ bool SGMetar::scanRwyVisRange()
 	r._max_visibility._distance = to;
 
 	if (*m == '/')					// this is not in the spec!
-		*m++;
+		m++;
 	if (*m == 'D')
 		m++, r._min_visibility._tendency = SGMetarVisibility::DECREASING;
 	else if (*m == 'N')
@@ -613,8 +527,8 @@ bool SGMetar::scanRwyVisRange()
 
 static const struct Token special[] = {
 	{ "NSW",  "no significant weather" },
-	{ "VCSH", "showers in the vicinity" },
-	{ "VCTS", "thunderstorm in the vicinity" },
+/*	{ "VCSH", "showers in the vicinity" },
+	{ "VCTS", "thunderstorm in the vicinity" }, */
 	{ 0, 0 }
 };
 
@@ -667,6 +581,7 @@ bool SGMetar::scanWeather()
 	char *m = _m;
 	string weather;
 	const struct Token *a;
+
 	if ((a = scanToken(&m, special))) {
 		if (!scanBoundary(&m))
 			return false;
@@ -676,32 +591,35 @@ bool SGMetar::scanWeather()
 	}
 
 	string pre, post;
-	int intensity = 0;
+    struct Weather w;
 	if (*m == '-')
-		m++, pre = "light ", intensity = 1;
+		m++, pre = "light ", w.intensity = LIGHT;
 	else if (*m == '+')
-		m++, pre = "heavy ", intensity = 3;
+		m++, pre = "heavy ", w.intensity = HEAVY;
 	else if (!strncmp(m, "VC", 2))
-		m += 2, post = "in the vicinity ";
+        m += 2, post = "in the vicinity ", w.vincinity=true;
 	else
-		pre = "moderate ", intensity = 2;
+		pre = "moderate ", w.intensity = MODERATE;
 
 	int i;
 	for (i = 0; i < 3; i++) {
 		if (!(a = scanToken(&m, description)))
 			break;
+		w.descriptions.push_back(a->id);
 		weather += string(a->text) + " ";
 	}
+
 	for (i = 0; i < 3; i++) {
 		if (!(a = scanToken(&m, phenomenon)))
 			break;
+        w.phenomena.push_back(a->id);
 		weather += string(a->text) + " ";
 		if (!strcmp(a->id, "RA"))
-			_rain = intensity;
+			_rain = w.intensity;
 		else if (!strcmp(a->id, "HA"))
-			_hail = intensity;
+			_hail = w.intensity;
 		else if (!strcmp(a->id, "SN"))
-			_snow = intensity;
+			_snow = w.intensity;
 	}
 	if (!weather.length())
 		return false;
@@ -711,6 +629,8 @@ bool SGMetar::scanWeather()
 	weather = pre + weather + post;
 	weather.erase(weather.length() - 1);
 	_weather.push_back(weather);
+    if( w.phenomena.size() > 0 )
+        _weather2.push_back( w );
 	_grpcount++;
 	return true;
 }
@@ -739,7 +659,7 @@ static const struct Token cloud_types[] = {
 	{ 0, 0 }
 };
 
-
+#include <iostream>
 // (FEW|SCT|BKN|OVC|SKC|CLR|CAVOK|VV)([0-9]{3}|///)?[:cloud_type:]?
 bool SGMetar::scanSkyCondition()
 {
@@ -757,6 +677,7 @@ bool SGMetar::scanSkyCondition()
 
 	if (!strncmp(m, "CLR", i = 3)				// clear
 			|| !strncmp(m, "SKC", i = 3)		// sky clear
+			|| !strncmp(m, "NCD", i = 3)		// nil cloud detected
 			|| !strncmp(m, "NSC", i = 3)		// no significant clouds
 			|| !strncmp(m, "CAVOK", i = 5))	{	// ceiling and visibility OK (implies 9999)
 		m += i;
@@ -764,7 +685,7 @@ bool SGMetar::scanSkyCondition()
 			return false;
 
 		if (i == 3) {
-			cl._coverage = 0;
+            cl._coverage = SGMetarCloud::COVERAGE_CLEAR;
 			_clouds.push_back(cl);
 		} else {
 			_cavok = true;
@@ -776,13 +697,13 @@ bool SGMetar::scanSkyCondition()
 	if (!strncmp(m, "VV", i = 2))				// vertical visibility
 		;
 	else if (!strncmp(m, "FEW", i = 3))
-		cl._coverage = 1;
+        cl._coverage = SGMetarCloud::COVERAGE_FEW;
 	else if (!strncmp(m, "SCT", i = 3))
-		cl._coverage = 2;
+        cl._coverage = SGMetarCloud::COVERAGE_SCATTERED;
 	else if (!strncmp(m, "BKN", i = 3))
-		cl._coverage = 3;
+        cl._coverage = SGMetarCloud::COVERAGE_BROKEN;
 	else if (!strncmp(m, "OVC", i = 3))
-		cl._coverage = 4;
+        cl._coverage = SGMetarCloud::COVERAGE_OVERCAST;
 	else
 		return false;
 	m += i;
@@ -795,7 +716,7 @@ bool SGMetar::scanSkyCondition()
 	} else if (!scanNumber(&m, &i, 3))
 		i = -1;
 
-	if (cl._coverage == -1) {
+    if (cl._coverage == SGMetarCloud::COVERAGE_NIL) {
 		if (!scanBoundary(&m))
 			return false;
 		if (i == -1)			// 'VV///'
@@ -1182,7 +1103,7 @@ const struct Token *SGMetar::scanToken(char **str, const struct Token *list)
 {
 	const struct Token *longest = 0;
 	int maxlen = 0, len;
-	char *s;
+	const char *s;
 	for (int i = 0; (s = list[i].id); i++) {
 		len = strlen(s);
 		if (!strncmp(s, *str, len) && len > maxlen) {
@@ -1195,13 +1116,29 @@ const struct Token *SGMetar::scanToken(char **str, const struct Token *list)
 }
 
 
-void SGMetarCloud::set(double alt, int cov)
+void SGMetarCloud::set(double alt, Coverage cov)
 {
 	_altitude = alt;
 	if (cov != -1)
 		_coverage = cov;
 }
 
+SGMetarCloud::Coverage SGMetarCloud::getCoverage( const std::string & coverage ) 
+{
+	if( coverage == "clear" ) return COVERAGE_CLEAR;
+	if( coverage == "few" ) return COVERAGE_FEW;
+	if( coverage == "scattered" ) return COVERAGE_SCATTERED;
+	if( coverage == "broken" ) return COVERAGE_BROKEN;
+	if( coverage == "overcast" ) return COVERAGE_OVERCAST;
+	return COVERAGE_NIL;
+}
+
+const char * SGMetarCloud::COVERAGE_NIL_STRING = "nil";
+const char * SGMetarCloud::COVERAGE_CLEAR_STRING = "clear";
+const char * SGMetarCloud::COVERAGE_FEW_STRING = "few";
+const char * SGMetarCloud::COVERAGE_SCATTERED_STRING = "scattered";
+const char * SGMetarCloud::COVERAGE_BROKEN_STRING = "broken";
+const char * SGMetarCloud::COVERAGE_OVERCAST_STRING = "overcast";
 
 void SGMetarVisibility::set(double dist, int dir, int mod, int tend)
 {

simgear/environment/metar.hxx

@@ -29,18 +29,12 @@
 
 #include <simgear/constants.h>
 
-SG_USING_STD(vector);
-SG_USING_STD(map);
-SG_USING_STD(string);
-
-const double SGMetarNaN = -1E20;
-#define NaN SGMetarNaN
-
 struct Token {
-	char	*id;
-	char	*text;
+	const char *id;
+	const char *text;
 };
 
+const double SGMetarNaN = -1E20;
 
 class SGMetar;
 
@@ -48,7 +42,7 @@ class SGMetarVisibility {
 	friend class SGMetar;
 public:
 	SGMetarVisibility() :
-		_distance(NaN),
+		_distance(SGMetarNaN),
 		_direction(-1),
 		_modifier(EQUALS),
 		_tendency(NONE) {}
@@ -70,8 +64,8 @@ public:
 	void set(double dist, int dir = -1, int mod = -1, int tend = -1);
 
 	inline double	getVisibility_m()	const { return _distance; }
-	inline double	getVisibility_ft()	const { return _distance == NaN ? NaN : _distance * SG_METER_TO_FEET; }
-	inline double	getVisibility_sm()	const { return _distance == NaN ? NaN : _distance * SG_METER_TO_SM; }
+	inline double	getVisibility_ft()	const { return _distance == SGMetarNaN ? SGMetarNaN : _distance * SG_METER_TO_FEET; }
+	inline double	getVisibility_sm()	const { return _distance == SGMetarNaN ? SGMetarNaN : _distance * SG_METER_TO_SM; }
 	inline int	getDirection()		const { return _direction; }
 	inline int	getModifier()		const { return _modifier; }
 	inline int	getTendency()		const { return _tendency; }
@@ -93,8 +87,8 @@ public:
 		_deposit_string(0),
 		_extent(-1),
 		_extent_string(0),
-		_depth(NaN),
-		_friction(NaN),
+		_depth(SGMetarNaN),
+		_friction(SGMetarNaN),
 		_friction_string(0),
 		_comment(0),
 		_wind_shear(false) {}
@@ -107,7 +101,7 @@ public:
 	inline double			getFriction()		const { return _friction; }
 	inline const char		*getFrictionString()	const { return _friction_string; }
 	inline const char		*getComment()		const { return _comment; }
-	inline const bool		getWindShear()		const { return _wind_shear; }
+	inline       bool		getWindShear()		const { return _wind_shear; }
 	inline const SGMetarVisibility&	getMinVisibility()	const { return _min_visibility; }
 	inline const SGMetarVisibility&	getMaxVisibility()	const { return _max_visibility; }
 
@@ -130,32 +124,44 @@ protected:
 class SGMetarCloud {
 	friend class SGMetar;
 public:
-	SGMetarCloud() :
-		_coverage(-1),
-		_altitude(NaN),
-		_type(0),
-		_type_long(0) {}
+	enum Coverage {
+		COVERAGE_NIL = -1,
+		COVERAGE_CLEAR = 0,
+		COVERAGE_FEW = 1,
+		COVERAGE_SCATTERED = 2,
+		COVERAGE_BROKEN = 3,
+		COVERAGE_OVERCAST = 4
+	};
 
-	void set(double alt, int cov = -1);
+	static const char * COVERAGE_NIL_STRING;
+	static const char * COVERAGE_CLEAR_STRING;
+	static const char * COVERAGE_FEW_STRING;
+	static const char * COVERAGE_SCATTERED_STRING;
+	static const char * COVERAGE_BROKEN_STRING;
+	static const char * COVERAGE_OVERCAST_STRING;
 
-	inline int	getCoverage()		const { return _coverage; }
-	inline double	getAltitude_m()		const { return _altitude; }
-	inline double	getAltitude_ft()	const { return _altitude == NaN ? NaN : _altitude * SG_METER_TO_FEET; }
-	inline char	*getTypeString()	const { return _type; }
-	inline char	*getTypeLongString()	const { return _type_long; }
+	SGMetarCloud() : _coverage(COVERAGE_NIL), _altitude(SGMetarNaN), _type(0), _type_long(0) {}
+
+	void set(double alt, Coverage cov = COVERAGE_NIL );
+
+	inline Coverage getCoverage() const { return _coverage; }
+	static Coverage getCoverage( const std::string & coverage );
+	inline double getAltitude_m() const { return _altitude; }
+	inline double getAltitude_ft() const { return _altitude == SGMetarNaN ? SGMetarNaN : _altitude * SG_METER_TO_FEET; }
+	inline const char *getTypeString() const { return _type; }
+	inline const char *getTypeLongString() const { return _type_long; }
 
 protected:
-	int	_coverage;		// quarters: 0 -> clear ... 4 -> overcast
-	double	_altitude;		// 1000 m
-	char	*_type;			// CU
-	char	*_type_long;		// cumulus
+	Coverage _coverage;     // quarters: 0 -> clear ... 4 -> overcast
+	double _altitude;       // 1000 m
+	const char *_type;      // CU
+	const char *_type_long; // cumulus
 };
 
 
 class SGMetar {
 public:
-	SGMetar(const string& m, const string& proxy = "", const string& port = "",
-			const string &auth = "", const time_t time = 0);
+	SGMetar(const std::string& m);
 	~SGMetar();
 
 	enum ReportType {
@@ -165,9 +171,24 @@ public:
 		RTD
 	};
 
+	enum Intensity {
+		NIL = 0,
+		LIGHT = 1,
+		MODERATE = 2,
+		HEAVY = 3
+	};
+
+	struct Weather {
+		Weather() { intensity = NIL; vincinity = false; }
+		Intensity intensity;
+		bool      vincinity;
+		std::vector<std::string> descriptions;
+		std::vector<std::string> phenomena;
+	};
+
 	inline const char *getData()		const { return _data; }
 	inline const char *getUnusedData()	const { return _m; }
-	inline const bool getProxy()		const { return _x_proxy; }
+	inline       bool getProxy()		const { return _x_proxy; }
 	inline const char *getId()		const { return _icao; }
 	inline int	getYear()		const { return _year; }
 	inline int	getMonth()		const { return _month; }
@@ -178,14 +199,14 @@ public:
 
 	inline int	getWindDir()		const { return _wind_dir; }
 	inline double	getWindSpeed_mps()	const { return _wind_speed; }
-	inline double	getWindSpeed_kmh()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_KMH; }
-	inline double	getWindSpeed_kt()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_KT; }
-	inline double	getWindSpeed_mph()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_MPH; }
+	inline double	getWindSpeed_kmh()	const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_KMH; }
+	inline double	getWindSpeed_kt()	const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_KT; }
+	inline double	getWindSpeed_mph()	const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_MPH; }
 
 	inline double	getGustSpeed_mps()	const { return _gust_speed; }
-	inline double	getGustSpeed_kmh()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_KMH; }
-	inline double	getGustSpeed_kt()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_KT; }
-	inline double	getGustSpeed_mph()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_MPH; }
+	inline double	getGustSpeed_kmh()	const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_KMH; }
+	inline double	getGustSpeed_kt()	const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_KT; }
+	inline double	getGustSpeed_mph()	const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_MPH; }
 
 	inline int	getWindRangeFrom()	const { return _wind_range_from; }
 	inline int	getWindRangeTo()	const { return _wind_range_to; }
@@ -196,11 +217,11 @@ public:
 	inline const SGMetarVisibility *getDirVisibility()	const { return _dir_visibility; }
 
 	inline double	getTemperature_C()	const { return _temp; }
-	inline double	getTemperature_F()	const { return _temp == NaN ? NaN : 1.8 * _temp + 32; }
+	inline double	getTemperature_F()	const { return _temp == SGMetarNaN ? SGMetarNaN : 1.8 * _temp + 32; }
 	inline double	getDewpoint_C()		const { return _dewp; }
-	inline double	getDewpoint_F()		const { return _dewp == NaN ? NaN : 1.8 * _dewp + 32; }
-	inline double	getPressure_hPa()	const { return _pressure == NaN ? NaN : _pressure / 100; }
-	inline double	getPressure_inHg()	const { return _pressure == NaN ? NaN : _pressure * SG_PA_TO_INHG; }
+	inline double	getDewpoint_F()		const { return _dewp == SGMetarNaN ? SGMetarNaN : 1.8 * _dewp + 32; }
+	inline double	getPressure_hPa()	const { return _pressure == SGMetarNaN ? SGMetarNaN : _pressure / 100; }
+	inline double	getPressure_inHg()	const { return _pressure == SGMetarNaN ? SGMetarNaN : _pressure * SG_PA_TO_INHG; }
 
 	inline int	getRain()		const { return _rain; }
 	inline int	getHail()		const { return _hail; }
@@ -209,12 +230,13 @@ public:
 
 	double		getRelHumidity()	const;
 
-	inline const vector<SGMetarCloud>& getClouds()	const	{ return _clouds; }
-	inline const map<string, SGMetarRunway>& getRunways()	const	{ return _runways; }
-	inline const vector<string>& getWeather()		const	{ return _weather; }
+	inline const std::vector<SGMetarCloud>& getClouds()	const	{ return _clouds; }
+	inline const std::map<std::string, SGMetarRunway>& getRunways()	const	{ return _runways; }
+	inline const std::vector<std::string>& getWeather()		const	{ return _weather; }
+	inline const std::vector<struct Weather> getWeather2()	const   { return _weather2; }
 
 protected:
-	string	_url;
+	std::string	_url;
 	int	_grpcount;
 	bool	_x_proxy;
 	char	*_data;
@@ -238,14 +260,15 @@ protected:
 	int	_hail;
 	int	_snow;
 	bool	_cavok;
+	std::vector<struct Weather> _weather2;
 
 	SGMetarVisibility		_min_visibility;
 	SGMetarVisibility		_max_visibility;
 	SGMetarVisibility		_vert_visibility;
 	SGMetarVisibility		_dir_visibility[8];
-	vector<SGMetarCloud>		_clouds;
-	map<string, SGMetarRunway>	_runways;
-	vector<string>			_weather;
+	std::vector<SGMetarCloud>		_clouds;
+	std::map<std::string, SGMetarRunway>	_runways;
+	std::vector<std::string>			_weather;
 
 	bool	scanPreambleDate();
 	bool	scanPreambleTime();
@@ -273,10 +296,7 @@ protected:
 	int	scanNumber(char **str, int *num, int min, int max = 0);
 	bool	scanBoundary(char **str);
 	const struct Token *scanToken(char **str, const struct Token *list);
-	char	*loadData(const char *id, const string& proxy, const string& port,
-			const string &auth, time_t time);
 	void	normalizeData();
 };
 
-#undef NaN
 #endif // _METAR_HXX

simgear/environment/precipitation.cxx

@@ -0,0 +1,203 @@
+/**
+ * @file precipitation.cxx
+ * @author Nicolas VIVIEN
+ * @date 2008-02-10
+ *
+ * @note Copyright (C) 2008 Nicolas VIVIEN
+ *
+ * @brief Precipitation effects to draw rain and snow.
+ *
+ * @par Licences
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License as
+ *   published by the Free Software Foundation; either version 2 of the
+ *   License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *   General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#include "precipitation.hxx"
+//#include "visual_enviro.hxx"
+
+#include <simgear/constants.h>
+#include <osg/ClipNode>
+
+/**
+ * @brief SGPrecipitation constructor
+ *
+ * Build a new OSG object from osgParticle.
+ */
+SGPrecipitation::SGPrecipitation() :
+    _freeze(false), _enabled(true), _snow_intensity(0.0), _rain_intensity(0.0), _clip_distance(5.0)
+{
+    _precipitationEffect = new osgParticle::PrecipitationEffect;
+}
+
+void SGPrecipitation::setEnabled( bool value )
+{
+    _enabled = value;
+}
+
+bool SGPrecipitation::getEnabled() const
+{
+    return _enabled;
+}
+
+/**
+ * @brief Build and add the object "precipitationEffect"
+ *
+ * This function permits you to create an object precipitationEffect and initialize it.
+ * I define by default the color of water (for raining)
+ */
+osg::Group* SGPrecipitation::build(void)
+{
+    osg::Group* group = new osg::Group;
+
+    _precipitationEffect->snow(0);	
+    _precipitationEffect->rain(0);	
+
+    if (_clip_distance!=0.0)
+    {    
+        osg::ref_ptr<osg::ClipNode> clipNode = new osg::ClipNode;
+        clipNode->addClipPlane( new osg::ClipPlane( 0 ) );
+        clipNode->getClipPlane(0)->setClipPlane( 0.0, 0.0, -1.0, -_clip_distance );
+        clipNode->setReferenceFrame(osg::ClipNode::ABSOLUTE_RF);
+        clipNode->addChild(_precipitationEffect.get());
+
+        group->addChild(clipNode.get());
+    }
+    else
+    {
+        group->addChild(_precipitationEffect.get());
+    }
+
+    return group;
+}
+
+
+/**
+ * @brief Define the snow intensity
+ *
+ * This function permits you to define and change the snow intensity
+ * The param 'intensity' is normed (0 to 1).
+ */
+void SGPrecipitation::setSnowIntensity(float intensity)
+{
+    if (this->_snow_intensity < intensity-0.001)
+        this->_snow_intensity += 0.001;
+    else if (this->_snow_intensity > intensity+0.001)
+        this->_snow_intensity -= 0.001;
+    else
+        this->_snow_intensity = intensity;
+}
+
+
+/**
+ * @brief Define the rain intensity
+ *
+ * This function permits you to define and change the rain intensity
+ * The param 'intensity' is normed (0 to 1).
+ */
+void SGPrecipitation::setRainIntensity(float intensity)
+{
+    if (this->_rain_intensity < intensity-0.001)
+        this->_rain_intensity += 0.001;
+    else if (this->_rain_intensity > intensity+0.001)
+        this->_rain_intensity -= 0.001;
+    else
+        this->_rain_intensity = intensity;
+}
+
+
+/** 
+ * @brief Freeze the rain to snow
+ * 
+ * @param freeze Boolean 
+ * 
+ * This function permits you to turn off the rain to snow.
+ */
+void SGPrecipitation::setFreezing(bool freeze)
+{
+    this->_freeze = freeze;
+}
+
+
+/**
+ * @brief Define the wind direction and speed
+ *
+ * This function permits you to define and change the wind direction
+ * 
+ * After apply the MatrixTransform to the osg::Precipitation object,
+ * x points full south... From wind heading and speed, we can calculate
+ * the wind vector.
+ */
+void SGPrecipitation::setWindProperty(double heading, double speed)
+{
+    double x, y, z;
+
+    heading = (heading + 180) * SGD_DEGREES_TO_RADIANS;
+    speed = speed * SG_FEET_TO_METER;
+
+    x = -cos(heading) * speed;
+    y = sin(heading) * speed;
+    z = 0;
+
+    this->_wind_vec = osg::Vec3(x, y, z);
+}
+
+
+/**
+ * @brief Update the precipitation effects
+ *
+ * This function permits you to update the precipitation effects.
+ * Be careful, if snow and rain intensity are greater than '0', snow effect
+ * will be first.
+ *
+ * The settings come from the osgParticule/PrecipitationEffect.cpp exemple.
+ */
+bool SGPrecipitation::update(void)
+{
+    if (this->_freeze) {
+        if (this->_rain_intensity > 0) 
+            this->_snow_intensity = this->_rain_intensity;
+    }
+
+    if (_enabled && this->_snow_intensity > 0) {
+        _precipitationEffect->setWind(_wind_vec);
+        _precipitationEffect->setParticleSpeed( -0.75f - 0.25f*_snow_intensity);
+		
+        _precipitationEffect->setParticleSize(0.02f + 0.03f*_snow_intensity);
+        _precipitationEffect->setMaximumParticleDensity(_snow_intensity * 7.2f);
+        _precipitationEffect->setCellSize(osg::Vec3(5.0f / (0.25f+_snow_intensity), 5.0f / (0.25f+_snow_intensity), 5.0f));
+		
+        _precipitationEffect->setNearTransition(25.f);
+        _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_snow_intensity));
+		
+        _precipitationEffect->setParticleColor(osg::Vec4(0.85, 0.85, 0.85, 1.0) - osg::Vec4(0.1, 0.1, 0.1, 1.0) * _snow_intensity);
+    } else if (_enabled && this->_rain_intensity > 0) {
+        _precipitationEffect->setWind(_wind_vec);
+        _precipitationEffect->setParticleSpeed( -2.0f + -5.0f*_rain_intensity);
+		
+        _precipitationEffect->setParticleSize(0.01 + 0.02*_rain_intensity);
+        _precipitationEffect->setMaximumParticleDensity(_rain_intensity * 7.5f);
+        _precipitationEffect->setCellSize(osg::Vec3(5.0f / (0.25f+_rain_intensity), 5.0f / (0.25f+_rain_intensity), 5.0f));
+		
+        _precipitationEffect->setNearTransition(25.f);
+        _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_rain_intensity));
+		
+        _precipitationEffect->setParticleColor( osg::Vec4(0x7A, 0xCE, 0xFF, 0x80));
+    } else {
+        _precipitationEffect->snow(0);	
+        _precipitationEffect->rain(0);	
+    }
+
+    return true;
+}

simgear/environment/precipitation.hxx

@@ -0,0 +1,65 @@
+/**
+ * @file precipitation.hxx
+ * @author Nicolas VIVIEN
+ * @date 2008-02-10
+ *
+ * @note Copyright (C) 2008 Nicolas VIVIEN
+ *
+ * @brief Precipitation effects to draw rain and snow.
+ *
+ * @par Licences
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License as
+ *   published by the Free Software Foundation; either version 2 of the
+ *   License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *   General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef _PRECIPITATION_HXX
+#define _PRECIPITATION_HXX
+
+#include <osg/Group>
+#include <osg/Referenced>
+#include <osgParticle/PrecipitationEffect>
+
+
+class SGPrecipitation : public osg::Referenced
+{
+private:
+    bool _freeze;
+    bool _enabled;
+
+    float _snow_intensity;
+    float _rain_intensity;
+    float _clip_distance;
+	
+    int _wind_dir;
+    osg::Vec3 _wind_vec;
+	
+    osg::ref_ptr<osgParticle::PrecipitationEffect> _precipitationEffect;
+
+public:
+    SGPrecipitation();
+    virtual ~SGPrecipitation() {}
+    osg::Group* build(void);
+    bool update(void);
+	
+    void setWindProperty(double, double);
+    void setFreezing(bool);
+    void setRainIntensity(float);
+    void setSnowIntensity(float);
+
+    void setEnabled( bool );
+    bool getEnabled() const;
+};
+
+#endif

simgear/environment/test_metar.cxx

@@ -0,0 +1,76 @@
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+
+#ifdef _MSC_VER
+#   define  random  rand
+#endif
+
+#include <simgear/misc/sg_dir.hxx>
+#include <simgear/structure/exception.hxx>
+
+#include "metar.hxx"
+
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::string;
+
+#define COMPARE(a, b) \
+    if ((a) != (b))  { \
+        cerr << "failed:" << #a << " != " << #b << endl; \
+        cerr << "\tgot:" << a << endl; \
+        exit(1); \
+    }
+
+#define FUZZY_COMPARE(a, b, epsilon) \
+    if (fabs(a - b) > epsilon) { \
+        cerr << "failed:" << #a << " != " << #b << endl; \
+        cerr << "\tgot:" << a << endl; \
+        cerr << "\tepsilon:" << epsilon << endl; \
+    }
+
+#define VERIFY(a) \
+    if (!(a))  { \
+        cerr << "failed:" << #a << endl; \
+        exit(1); \
+    }
+
+const double TEST_EPSILON = 1e-9;
+
+void test_basic()
+{
+    SGMetar m1("2011/10/20 11:25 EHAM 201125Z 27012KT 240V300 9999 VCSH FEW025CB SCT048 10/05 Q1025 TEMPO VRB03KT");
+    COMPARE(m1.getYear(), 2011);
+    COMPARE(m1.getMonth(), 10);
+    COMPARE(m1.getDay(), 20);
+    COMPARE(m1.getHour(), 11);
+    COMPARE(m1.getMinute(), 25);
+    COMPARE(m1.getReportType(), -1); // should default to NIL?
+    
+    COMPARE(m1.getWindDir(), 270);
+    FUZZY_COMPARE(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
+    
+    FUZZY_COMPARE(m1.getTemperature_C(), 10, TEST_EPSILON);
+    FUZZY_COMPARE(m1.getDewpoint_C(), 5, TEST_EPSILON);
+    FUZZY_COMPARE(m1.getPressure_hPa(), 1025, TEST_EPSILON);
+}
+
+int main(int argc, char* argv[])
+{
+    try {
+    test_basic();
+    } catch (sg_exception& e) {
+        cerr << "got exception:" << e.getMessage() << endl;
+        return -1;
+    }
+    
+    return 0;
+}

simgear/environment/visual_enviro.cxx

@@ -1,9 +1,6 @@
 // Visual environment helper class
 //
 // Written by Harald JOHNSEN, started April 2005.
-// Minor changes/additions by Vivian Meazza Apr- May 2007
-//
-// Ported to OSG by Tim Moore Jun 2007
 //
 // Copyright (C) 2005  Harald JOHNSEN - hjohnsen@evc.net
 //
@@ -31,9 +28,7 @@
 #include <simgear/structure/SGSharedPtr.hxx>
 #include <simgear/math/sg_random.h>
 #include <simgear/math/sg_geodesy.hxx>
-#include <simgear/math/point3d.hxx>
-#include <simgear/math/polar3d.hxx>
-#include <simgear/sound/soundmgr_openal.hxx>
+#include <simgear/sound/sample_group.hxx>
 #include <simgear/scene/sky/cloudfield.hxx>
 #include <simgear/scene/sky/newcloud.hxx>
 #include <simgear/props/props.hxx>
@@ -41,11 +36,11 @@
 
 #include <vector>
 
-SG_USING_STD(vector);
+using std::vector;
 
 
 typedef struct {
-	Point3D		pt;
+	SGVec3d		pt;
 	int			depth;
 	int			prev;
 } lt_tree_seg;
@@ -55,23 +50,23 @@ static float rainpos[MAX_RAIN_SLICE];
 #define MAX_LT_TREE_SEG	400
 
 #define DFL_MIN_LIGHT 0.35
-sgVec3 SGEnviro::min_light = {DFL_MIN_LIGHT, DFL_MIN_LIGHT, DFL_MIN_LIGHT};
+SGVec3f SGEnviro::min_light(DFL_MIN_LIGHT, DFL_MIN_LIGHT, DFL_MIN_LIGHT);
 #define DFL_STREAK_BRIGHT_NEARMOST_LAYER 0.9
-SGfloat SGEnviro::streak_bright_nearmost_layer = DFL_STREAK_BRIGHT_NEARMOST_LAYER;
+float SGEnviro::streak_bright_nearmost_layer = DFL_STREAK_BRIGHT_NEARMOST_LAYER;
 #define DFL_STREAK_BRIGHT_FARMOST_LAYER 0.5
-SGfloat SGEnviro::streak_bright_farmost_layer = DFL_STREAK_BRIGHT_FARMOST_LAYER;
+float SGEnviro::streak_bright_farmost_layer = DFL_STREAK_BRIGHT_FARMOST_LAYER;
 #define DFL_STREAK_PERIOD_MAX 2.5
-SGfloat SGEnviro::streak_period_max = DFL_STREAK_PERIOD_MAX;
+float SGEnviro::streak_period_max = DFL_STREAK_PERIOD_MAX;
 #define DFL_STREAK_PERIOD_CHANGE_PER_KT 0.005
-SGfloat SGEnviro::streak_period_change_per_kt = DFL_STREAK_PERIOD_CHANGE_PER_KT;
+float SGEnviro::streak_period_change_per_kt = DFL_STREAK_PERIOD_CHANGE_PER_KT;
 #define DFL_STREAK_PERIOD_MIN 1.0
-SGfloat SGEnviro::streak_period_min = DFL_STREAK_PERIOD_MIN;
+float SGEnviro::streak_period_min = DFL_STREAK_PERIOD_MIN;
 #define DFL_STREAK_LENGTH_MIN 0.03
-SGfloat SGEnviro::streak_length_min = DFL_STREAK_LENGTH_MIN;
+float SGEnviro::streak_length_min = DFL_STREAK_LENGTH_MIN;
 #define DFL_STREAK_LENGTH_CHANGE_PER_KT 0.0005
-SGfloat SGEnviro::streak_length_change_per_kt = DFL_STREAK_LENGTH_CHANGE_PER_KT;
+float SGEnviro::streak_length_change_per_kt = DFL_STREAK_LENGTH_CHANGE_PER_KT;
 #define DFL_STREAK_LENGTH_MAX 0.1
-SGfloat SGEnviro::streak_length_max = DFL_STREAK_LENGTH_MAX;
+float SGEnviro::streak_length_max = DFL_STREAK_LENGTH_MAX;
 #define DFL_STREAK_COUNT_MIN 40
 int SGEnviro::streak_count_min = DFL_STREAK_COUNT_MIN;
 #define DFL_STREAK_COUNT_MAX 190
@@ -80,9 +75,9 @@ int SGEnviro::streak_count_min = DFL_STREAK_COUNT_MIN;
 #endif
 int SGEnviro::streak_count_max = DFL_STREAK_COUNT_MAX;
 #define DFL_CONE_BASE_RADIUS 15.0
-SGfloat SGEnviro::cone_base_radius = DFL_CONE_BASE_RADIUS;
+float SGEnviro::cone_base_radius = DFL_CONE_BASE_RADIUS;
 #define DFL_CONE_HEIGHT 30.0
-SGfloat SGEnviro::cone_height = DFL_CONE_HEIGHT;
+float SGEnviro::cone_height = DFL_CONE_HEIGHT;
 
 
 void SGEnviro::config(const SGPropertyNode* n)
@@ -91,7 +86,7 @@ void SGEnviro::config(const SGPropertyNode* n)
 		return;
 
 	const float ml = n->getFloatValue("min-light", DFL_MIN_LIGHT);
-	sgSetVec3(min_light, ml, ml, ml);
+  min_light = SGVec3f(ml, ml, ml);
 
 	streak_bright_nearmost_layer = n->getFloatValue(
 			"streak-brightness-nearmost-layer",
@@ -149,7 +144,7 @@ public:
 	~SGLightning();
 	void lt_Render(void);
 	void lt_build(void);
-	void lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize);
+	void lt_build_tree_branch(int tree_nr, SGVec3d &start, float energy, int nbseg, float segsize);
 
 	// contains all the segments of the lightning
 	lt_tree_seg lt_tree[MAX_LT_TREE_SEG];
@@ -178,7 +173,7 @@ SGEnviro::SGEnviro() :
 	lightning_enable_state(false),
 	elapsed_time(0.0),
 	dt(0.0),
-	soundMgr(NULL),
+	sampleGroup(NULL),
 	snd_active(false),
 	snd_dist(0.0),
 	min_time_before_lt(0.0),
@@ -192,28 +187,28 @@ SGEnviro::SGEnviro() :
 }
 
 SGEnviro::~SGEnviro(void) {
+  // if (sampleGroup) delete sampleGroup;
+
   // OSGFIXME
   return;
 	list_of_lightning::iterator iLightning;
-	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
+	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; ++iLightning ) {
 		delete (*iLightning);
 	}
 	lightnings.clear();
 }
 
-void SGEnviro::startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time) {
+void SGEnviro::startOfFrame( SGVec3f p, SGVec3f up, double lon, double lat, double alt, double delta_time) {
   // OSGFIXME
   return;
 	view_in_cloud = false;
 	// ask the impostor cache to do some cleanup
-	if(SGNewCloud::cldCache)
-		SGNewCloud::cldCache->startNewFrame();
 	last_cloud_turbulence = cloud_turbulence;
 	cloud_turbulence = 0.0;
 	elapsed_time += delta_time;
 	min_time_before_lt -= delta_time;
 	dt = delta_time;
-
+#if 0
 	sgMat4 T1, LON, LAT;
     sgVec3 axis;
 
@@ -235,6 +230,7 @@ void SGEnviro::startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double
     sgSetCoord( &pos, TRANSFORM );
 
 	sgMakeCoordMat4( transform, &pos );
+  #endif
     last_lon = lon;
     last_lat = lat;
 	last_alt = alt;
@@ -258,43 +254,10 @@ void SGEnviro::set_view_in_cloud(bool incloud) {
 	view_in_cloud = incloud;
 }
 
-int SGEnviro::get_CacheResolution(void) const {
-	return SGCloudField::get_CacheResolution();
-}
-
-int SGEnviro::get_clouds_CacheSize(void) const {
-	return SGCloudField::get_CacheSize();
-}
-float SGEnviro::get_clouds_visibility(void) const {
-	return SGCloudField::get_CloudVis();
-}
-float SGEnviro::get_clouds_density(void) const {
-	return SGCloudField::get_density();
-}
-bool SGEnviro::get_clouds_enable_state(void) const {
-	return SGCloudField::get_enable3dClouds();
-}
-
 bool SGEnviro::get_turbulence_enable_state(void) const {
 	return turbulence_enable_state;
 }
 
-void SGEnviro::set_CacheResolution(int resolutionPixels) {
-	SGCloudField::set_CacheResolution(resolutionPixels);
-}
-
-void SGEnviro::set_clouds_CacheSize(int sizeKb) {
-	SGCloudField::set_CacheSize(sizeKb);
-}
-void SGEnviro::set_clouds_visibility(float distance) {
-	SGCloudField::set_CloudVis(distance);
-}
-void SGEnviro::set_clouds_density(float density) {
-	SGCloudField::set_density(density);
-}
-void SGEnviro::set_clouds_enable_state(bool enable) {
-	SGCloudField::set_enable3dClouds(enable);
-}
 void SGEnviro::set_turbulence_enable_state(bool enable) {
 	turbulence_enable_state = enable;
 }
@@ -325,16 +288,16 @@ void SGEnviro::set_lightning_enable_state(bool enable) {
 	}
 }
 
-void SGEnviro::setLight(sgVec4 adj_fog_color) {
+void SGEnviro::setLight(SGVec4f adj_fog_color) {
   // OSGFIXME
   return;
-	sgCopyVec4( fog_color, adj_fog_color );
+	 fog_color = adj_fog_color;
 	if( false ) {
 	//    ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
 	}
 }
-
-void SGEnviro::callback_cloud(float bearing, float alt, float radius, int family, float dist, int cloudId) {
+#if 0
+void SGEnviro::callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId) {
 	// send data to wx radar
 	// compute turbulence
 	// draw precipitation
@@ -409,7 +372,7 @@ void SGEnviro::callback_cloud(float bearing, float alt, float radius, int family
 
 	// add to the list for the wxRadar instrument
 	if( LWC > 0.0 )
-		radarEcho.push_back( SGWxRadarEcho ( bearing, alt, radius, dist, 0.0 , LWC, false, cloudId, false ) );
+		radarEcho.push_back( SGWxRadarEcho ( heading, alt, radius, dist, LWC, false, cloudId ) );
 
 	// NB:data valid only from cockpit view
 
@@ -417,12 +380,12 @@ void SGEnviro::callback_cloud(float bearing, float alt, float radius, int family
 	if(lightning_enable_state && min_time_before_lt <= 0.0 && (family == SGNewCloud::CLFamilly_cb) &&
 		dist < 15000.0 * 15000.0 && sg_random() > 0.9f) {
 		double lat, lon;
-		Point3D orig, dest;
+		SGVec3d orig, dest;
 		orig.setlat(last_lat * SG_DEGREES_TO_RADIANS );
 		orig.setlon(last_lon * SG_DEGREES_TO_RADIANS );
 		orig.setelev(0.0);
 		dist = sgSqrt(dist);
-		dest = calc_gc_lon_lat(orig, bearing, dist);
+		dest = calc_gc_lon_lat(orig, heading, dist);
 		lon = dest.lon() * SG_RADIANS_TO_DEGREES;
 		lat = dest.lat() * SG_RADIANS_TO_DEGREES;
 		addLightning( lon, lat, alt );
@@ -444,6 +407,8 @@ void SGEnviro::callback_cloud(float bearing, float alt, float radius, int family
 		}
 }
 
+#endif
+
 list_of_SGWxRadarEcho *SGEnviro::get_radar_echo(void) {
 	return &radarEcho;
 }
@@ -452,122 +417,15 @@ list_of_SGWxRadarEcho *SGEnviro::get_radar_echo(void) {
 void SGEnviro::DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed) {
   // OSGFIXME
   return;
-	sgVec3 light;
-	sgAddVec3( light, fog_color, min_light );
-	float da = SG_PI * 2.0f / (float) slices;
-	// low number = faster
-	float speedf = streak_period_max - speed * streak_period_change_per_kt;
-	if( speedf < streak_period_min )
-		speedf = streak_period_min;
-	float lenf = streak_length_min + speed * streak_length_change_per_kt;
-	if( lenf > streak_length_max )
-		lenf = streak_length_max;
-    float t = fmod((float) elapsed_time, speedf) / speedf;
-//	t = 0.1f;
-	if( !down )
-		t = 1.0f - t;
-	float angle = 0.0f;
-	//glColor4f(1.0f, 0.7f, 0.7f, 0.9f); // XXX unneeded? overriden below
-	glBegin(GL_LINES);
-	if (slices >  MAX_RAIN_SLICE)
-		slices = MAX_RAIN_SLICE; // should never happen
-	for( int i = 0 ; i < slices ; i++ ) {
-		float x = cos(angle) * baseRadius;
-		float y = sin(angle) * baseRadius;
-		angle += da;
-		sgVec3 dir = {x, -height, y};
-
-		// rain drops at 2 different speed to simulate depth
-		float t1 = (i & 1 ? t : t + t) + rainpos[i];
-		if(t1 > 1.0f)	t1 -= 1.0f;
-		if(t1 > 1.0f)	t1 -= 1.0f;
-
-		// distant raindrops are more transparent
-		float c = t1 * (i & 1 ?
-				streak_bright_farmost_layer
-				: streak_bright_nearmost_layer);
-		glColor4f(c * light[0], c * light[1], c * light[2], c);
-		sgVec3 p1, p2;
-		sgScaleVec3(p1, dir, t1);
-		// distant raindrops are shorter
-		float t2 = t1 + (i & 1 ? lenf : lenf+lenf);
-		sgScaleVec3(p2, dir, t2);
-
-		glVertex3f(p1[0], p1[1] + height, p1[2]);
-		glVertex3f(p2[0], p2[1] + height, p2[2]);
-	}
-	glEnd();
 }
 
 void SGEnviro::drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm) {
   // OSGFIXME
   return;
-
-#if 0
-	static int debug_period = 0;
-	if (debug_period++ == 50) {
-		debug_period = 0;
-		cout << "drawRain("
-			<< pitch << ", "
-			<< roll  << ", "
-			<< heading << ", "
-			<< hspeed << ", "
-			<< rain_norm << ");"
-			//" angle = " << angle
-			//<< " raindrop(KTS) = " << raindrop_speed_kts
-			<< endl;
-	}
-#endif
-
-
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glDisable(GL_DEPTH_TEST);
-	glShadeModel(GL_SMOOTH);
-	glEnable(GL_BLEND);
-	glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
-	glDisable( GL_FOG );
-	glDisable(GL_LIGHTING);
-
-	int slice_count = static_cast<int>(
-			(streak_count_min + rain_norm*(streak_count_max-streak_count_min))
-				* precipitation_density / 100.0);
-
-	// www.wonderquest.com/falling-raindrops.htm says that
-	// Raindrop terminal velocity is 5 to 20mph
-	// Rather than model it accurately (temp, pressure, diameter), and make it
-	// smaller than terminal when closer to the precipitation cloud base,
-	// we interpolate in the 5-20mph range according to rain_norm.
-	double raindrop_speed_kts
-		= (5.0 + rain_norm*15.0) * SG_MPH_TO_MPS * SG_MPS_TO_KT;
-
-	float angle = atanf(hspeed / raindrop_speed_kts) * SG_RADIANS_TO_DEGREES;
-	glPushMatrix();
-		// the cone rotate with hspeed
-		angle = -pitch - angle;
-		glRotatef(roll, 0.0, 0.0, 1.0);
-		glRotatef(heading, 0.0, 1.0, 0.0);
-		glRotatef(angle, 1.0, 0.0, 0.0);
-
-		// up cone
-		DrawCone2(cone_base_radius, cone_height, 
-				slice_count, true, rain_norm, hspeed);
-		// down cone (usually not visible)
-		if(angle > 0.0 || heading != 0.0)
-			DrawCone2(cone_base_radius, -cone_height, 
-					slice_count, false, rain_norm, hspeed);
-
-	glPopMatrix();
-
-	glEnable(GL_LIGHTING);
-	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
-	glEnable( GL_FOG );
-	glEnable(GL_DEPTH_TEST);
-
 }
 
-void SGEnviro::set_soundMgr(SGSoundMgr *mgr) {
-	soundMgr = mgr;
+void SGEnviro::set_sampleGroup(SGSampleGroup *sgr) {
+	sampleGroup = sgr;
 }
 
 void SGEnviro::drawPrecipitation(double rain_norm, double snow_norm, double hail_norm, double pitch, double roll, double heading, double hspeed) {
@@ -594,169 +452,20 @@ SGLightning::~SGLightning() {
 }
 
 // lightning rendering code
-void SGLightning::lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize) {
+void SGLightning::lt_build_tree_branch(int tree_nr, SGVec3d &start, float energy, int nbseg, float segsize) {
   // OSGFIXME
   return;
-
-	sgVec3 dir, newdir;
-	int nseg = 0;
-	Point3D pt = start;
-	if( nbseg == 50 )
-		sgSetVec3( dir, 0.0, -1.0, 0.0 );
-	else {
-		sgSetVec3( dir, sg_random() - 0.5f, sg_random() - 0.5f, sg_random() - 0.5f);
-		sgNormaliseVec3(dir);
-	}
-	if( nb_tree >= MAX_LT_TREE_SEG )
-		return;
-
-	lt_tree[nb_tree].depth = tree_nr;
-	nseg = 0;
-	lt_tree[nb_tree].pt = pt;
-	lt_tree[nb_tree].prev = -1;
-	nb_tree ++;
-
-	// TODO:check agl
-	while(nseg < nbseg && pt.y() > 0.0) {
-        int prev = nb_tree - 1;
-        nseg++;
-		// add a branch
-        if( energy * sg_random() > 0.8f )
-			lt_build_tree_branch(tree_nr + 1, pt, energy * 0.9f, nbseg == 50 ? 10 : static_cast<int>(nbseg * 0.4f), segsize * 0.7f);
-
-		if( nb_tree >= MAX_LT_TREE_SEG )
-			return;
-		sgSetVec3(newdir, (sg_random() - 0.5f), (sg_random() - 0.5f) - (nbseg == 50 ? 0.5f : 0.0), (sg_random() - 0.5f));
-		sgNormaliseVec3(newdir);
-		sgAddVec3( dir, newdir);
-		sgNormaliseVec3(dir);
-		sgVec3 scaleDir;
-		sgScaleVec3( scaleDir, dir, segsize * energy * 0.5f );
-		pt[PX] += scaleDir[0];
-		pt[PY] += scaleDir[1];
-		pt[PZ] += scaleDir[2];
-
-		lt_tree[nb_tree].depth = tree_nr;
-		lt_tree[nb_tree].pt = pt;
-		lt_tree[nb_tree].prev = prev;
-		nb_tree ++;
-	}
 }
 
 void SGLightning::lt_build(void) {
   // OSGFIXME
   return;
-    Point3D top;
-    nb_tree = 0;
-    top[PX] = 0 ;
-    top[PY] = alt;
-    top[PZ] = 0;
-    lt_build_tree_branch(0, top, 1.0, 50, top[PY] / 8.0);
-	if( ! sgEnviro.soundMgr )
-		return;
-	Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-	Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
-	double course = 0.0, dist = 0.0;
-	calc_gc_course_dist( dest, start, &course, &dist );
-	if( dist < 10000.0 && ! sgEnviro.snd_playing && (dist < sgEnviro.snd_dist || ! sgEnviro.snd_active) ) {
-		sgEnviro.snd_timer = 0.0;
-		sgEnviro.snd_wait  = dist / 340;
-		sgEnviro.snd_dist  = dist;
-		sgEnviro.snd_pos_lat = lat;
-		sgEnviro.snd_pos_lon = lon;
-		sgEnviro.snd_active = true;
-		sgEnviro.snd_playing = false;
-	}
 }
 
 
 void SGLightning::lt_Render(void) {
   // OSGFIXME
   return;
-	float flash = 0.5;
-	if( fmod(sgEnviro.elapsed_time*100.0, 100.0) > 50.0 )
-		flash = sg_random() * 0.75f + 0.25f;
-    float h = lt_tree[0].pt[PY];
-	sgVec4 col={0.62f, 0.83f, 1.0f, 1.0f};
-	sgVec4 c;
-
-#define DRAW_SEG() \
-			{glColorMaterial(GL_FRONT, GL_EMISSION);  \
-			glDisable(GL_LINE_SMOOTH); glBegin(GL_LINES); \
-				glColor4fv(c); \
-                glVertex3f(lt_tree[n].pt[PX], lt_tree[n].pt[PZ], lt_tree[n].pt[PY]); \
-                glVertex3f(lt_tree[lt_tree[n].prev].pt[PX], lt_tree[lt_tree[n].prev].pt[PZ], lt_tree[lt_tree[n].prev].pt[PY]); \
-			glEnd(); glEnable(GL_LINE_SMOOTH);}
-
-	glDepthMask( GL_FALSE );
-	glEnable(GL_BLEND);
-	glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glDisable(GL_LIGHTING);
-	glDisable( GL_FOG );
-	glPushMatrix();
-	sgMat4 modelview, tmp;
-    // OSGFIXME
-//     ssgGetModelviewMatrix( modelview );
-	sgCopyMat4( tmp, sgEnviro.transform );
-    sgPostMultMat4( tmp, modelview );
-    // OSGFIXME
-//     ssgLoadModelviewMatrix( tmp );
-
-    Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-    Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
-    double course = 0.0, dist = 0.0;
-    calc_gc_course_dist( dest, start, &course, &dist );
-    double ax = 0.0, ay = 0.0;
-    ax = cos(course) * dist;
-    ay = sin(course) * dist;
-
-	glTranslatef( ax, ay, -sgEnviro.last_alt );
-
-	sgEnviro.radarEcho.push_back( SGWxRadarEcho ( course, 0.0, 0.0, dist, 0.0, age, true, 0, false ) );
-
-	for( int n = 0 ; n < nb_tree ; n++ ) {
-        if( lt_tree[n].prev < 0 )
-			continue;
-
-        float t1 = sgLerp(0.5, 1.0, lt_tree[n].pt[PY] / h);
-		t1 *= flash;
-		if( lt_tree[n].depth >= 2 ) {
-            glLineWidth(3);
-			sgScaleVec4(c, col, t1 * 0.6f);
-			DRAW_SEG();
-		} else {
-			if( lt_tree[n].depth == 0 ) {
-                glLineWidth(12);
-				sgScaleVec4(c, col, t1 * 0.5f);
-				DRAW_SEG();
-
-                glLineWidth(6);
-				sgScaleVec4(c, col, t1);
-				DRAW_SEG();
-			} else {
-                glLineWidth(6);
-				sgScaleVec4(c, col, t1 * 0.7f);
-				DRAW_SEG();
-			}
-
-            if( lt_tree[n].depth == 0 ) 
-                glLineWidth(3);
-			else
-                glLineWidth(2);
-
-            sgSetVec4(c, t1, t1, t1, t1);
-			DRAW_SEG();
-		}
-
-	}
-    glLineWidth(1);
-	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
-	glPopMatrix();
-	glDepthMask( GL_TRUE );	
-	glEnable( GL_FOG );
-	glEnable(GL_LIGHTING);
 }
 
 void SGEnviro::addLightning(double lon, double lat, double alt) {
@@ -771,52 +480,6 @@ void SGEnviro::addLightning(double lon, double lat, double alt) {
 void SGEnviro::drawLightning(void) {
   // OSGFIXME
   return;
-	list_of_lightning::iterator iLightning;
-	// play 'thunder' for lightning
-	if( snd_active )
-		if( !snd_playing ) {
-			// wait until sound has reached us
-			snd_timer += dt;
-			if( snd_timer >= snd_wait ) {
-				snd_playing = true;
-				// compute relative position of lightning
-				Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-				Point3D dest( snd_pos_lon*SG_DEGREES_TO_RADIANS, snd_pos_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-				double course = 0.0, dist = 0.0;
-				calc_gc_course_dist( dest, start, &course, &dist );
-				double ax = 0.0, ay = 0.0;
-				ax = cos(course) * dist;
-				ay = sin(course) * dist;
-				SGSharedPtr<SGSoundSample> snd = soundMgr->find("thunder");
-				if( snd ) {
-					ALfloat pos[3]={ax, ay, -sgEnviro.last_alt };
-					snd->set_source_pos(pos);
-					snd->play_once();
-				}
-			}
-		} else {
-			if( !soundMgr->is_playing("thunder") ) {
-				snd_active = false;
-				snd_playing = false;
-			}
-		}
-
-	if( ! lightning_enable_state )
-		return;
-
-	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
-		if( dt )
-			if( sg_random() > 0.95f )
-				(*iLightning)->lt_build();
-		(*iLightning)->lt_Render();
-		(*iLightning)->age -= dt;
-		if( (*iLightning)->age < 0.0 ) {
-			delete (*iLightning);
-			lightnings.erase( iLightning );
-			break;
-		}
-	}
-
 }
 
 

simgear/environment/visual_enviro.hxx

@@ -1,9 +1,6 @@
 // Visual environment helper class
 //
 // Written by Harald JOHNSEN, started April 2005.
-// Minor changes/additions by Vivian Meazza Apr- May 2007
-//
-// Ported to OSG by Tim Moore Jun 2007
 //
 // Copyright (C) 2005  Harald JOHNSEN - hjohnsen@evc.net
 //
@@ -25,17 +22,14 @@
 #ifndef _VISUAL_ENVIRO_HXX
 #define _VISUAL_ENVIRO_HXX
 
-#include <plib/sg.h>
-
 #include <simgear/compiler.h>
-#include STL_STRING
+#include <string>
 #include <vector>
 
-SG_USING_STD(vector);
-SG_USING_STD(string);
+#include <simgear/math/SGMath.hxx>
 
 class SGLightning;
-class SGSoundMgr;
+class SGSampleGroup;
 
 /**
  * Simulate some echo on a weather radar.
@@ -43,37 +37,29 @@ class SGSoundMgr;
  */
 class SGWxRadarEcho {
 public:
-	SGWxRadarEcho(float _bearing, float _alt, float _radius, float _dist, float _heading,
-			double _LWC, bool _lightning, int _cloudId, bool _aircraft) :
-	  bearing (_bearing),
+	SGWxRadarEcho(float _heading, float _alt, float _radius, float _dist,
+			double _LWC, bool _lightning, int _cloudId ) :
 	  heading( _heading ),
 	  alt ( _alt ),
 	  radius ( _radius ),
 	  dist ( _dist ),
 	  LWC ( _LWC ),
 	  lightning ( _lightning ),
-	  aircraft ( _aircraft ),
 	  cloudId ( _cloudId )
 	{}
 
-	/** the heading and bearing in radian are versus north */
-	float bearing, heading;
+	/** the heading in radian is versus north */
+	float heading;
 	float alt, radius, dist;
-
 	/** reflectivity converted to liquid water content. */
 	double LWC;
-
 	/** if true then this data is for a lightning else it is for water echo. */
-	bool   lightning;
-
-	/** if true then this data is for an aircraft  */
-	bool aircraft;
-
+	bool lightning;
 	/** Unique identifier of cloud */
 	int cloudId;
 };
 
-typedef vector<SGWxRadarEcho> list_of_SGWxRadarEcho;
+typedef std::vector<SGWxRadarEcho> list_of_SGWxRadarEcho;
 
 /**
  * Visual environment helper class.
@@ -92,10 +78,10 @@ private:
 	double last_cloud_turbulence, cloud_turbulence;
 	bool lightning_enable_state;
 	double elapsed_time, dt;
-	sgVec4	fog_color;
-	sgMat4 transform;
+	SGVec4f	fog_color;
+	SGMatrixf transform;
 	double last_lon, last_lat, last_alt;
-	SGSoundMgr	*soundMgr;
+	SGSampleGroup	*sampleGroup;
 	bool		snd_active, snd_playing;
 	double		snd_timer, snd_wait, snd_pos_lat, snd_pos_lon, snd_dist;
 	double		min_time_before_lt;
@@ -104,8 +90,8 @@ private:
 
 	/** a list of all the radar echo. */
 	list_of_SGWxRadarEcho radarEcho;
-	static sgVec3 min_light;
-	static SGfloat streak_bright_nearmost_layer,
+	static SGVec3f min_light;
+	static float streak_bright_nearmost_layer,
 				   streak_bright_farmost_layer,
 				   streak_period_max,
 				   streak_period_change_per_kt,
@@ -114,7 +100,7 @@ private:
 				   streak_length_change_per_kt,
 				   streak_length_max;
 	static int streak_count_min, streak_count_max;
-	static SGfloat cone_base_radius,
+	static float cone_base_radius,
 				   cone_height;
 
 public:
@@ -132,10 +118,11 @@ public:
     /**
      * Forward a few states used for renderings.
      */
-	void startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time);
+	void startOfFrame( SGVec3f p, SGVec3f up, double lon, double lat, double alt, double delta_time);
 
 	void endOfFrame(void);
 
+#if 0
     /**
      * Whenever a cloud is drawn we check his 'impact' on the environment.
      * @param heading direction of cloud in radians
@@ -145,7 +132,7 @@ public:
      * @param dist  squared dist to cloud in meters
      */
 	void callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId);
-
+#endif
 	void drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm);
     /**
      * Draw rain or snow precipitation around the viewer.
@@ -168,7 +155,7 @@ public:
      * Forward the fog color used by the rain rendering.
      * @param adj_fog_color color of the fog
      */
-	void setLight(sgVec4 adj_fog_color);
+	void setLight(SGVec4f adj_fog_color);
 
 	// this can be queried to add some turbulence for example
 	bool is_view_in_cloud(void) const;
@@ -253,14 +240,14 @@ public:
      * Forward the sound manager instance to be able to play samples.
      * @param mgr a running sound manager
      */
-	void set_soundMgr(SGSoundMgr *mgr);
+	void set_sampleGroup(SGSampleGroup *sgr);
 
 	void setFOV( float w, float h );
 	void getFOV( float &w, float &h );
 
 	list_of_SGWxRadarEcho *get_radar_echo(void);
 
-	sgMat4 *get_transform(void) { return &transform; }
+	SGMatrixf *get_transform(void) { return &transform; }
 };
 
 extern SGEnviro sgEnviro;

simgear/ephemeris/.cvsignore

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

simgear/ephemeris/CMakeLists.txt

@@ -0,0 +1,35 @@
+
+include (SimGearComponent)
+
+set(HEADERS 
+    celestialBody.hxx
+    ephemeris.hxx
+    jupiter.hxx
+    mars.hxx
+    mercury.hxx
+    moonpos.hxx
+    neptune.hxx
+    pluto.hxx
+    saturn.hxx
+    star.hxx
+    stardata.hxx
+    uranus.hxx
+    venus.hxx
+    )
+    
+set(SOURCES 
+    celestialBody.cxx
+    ephemeris.cxx
+    jupiter.cxx
+    mars.cxx
+    mercury.cxx
+    moonpos.cxx
+    neptune.cxx
+    saturn.cxx
+    star.cxx
+    stardata.cxx
+    uranus.cxx
+    venus.cxx
+    )
+
+simgear_component(ephem ephemeris "${SOURCES}" "${HEADERS}")

simgear/ephemeris/Makefile.am

@@ -1,34 +0,0 @@
-includedir = @includedir@/ephemeris
-
-lib_LIBRARIES = libsgephem.a
-
-include_HEADERS = \
-	celestialBody.hxx \
-	ephemeris.hxx \
-	jupiter.hxx \
-	mars.hxx \
-	mercury.hxx \
-	moonpos.hxx \
-	neptune.hxx \
-	saturn.hxx \
-	star.hxx \
-	stardata.hxx \
-	uranus.hxx \
-	venus.hxx
-
-libsgephem_a_SOURCES = \
-	celestialBody.cxx \
-	ephemeris.cxx \
-	jupiter.cxx \
-	mars.cxx \
-	mercury.cxx \
-	moonpos.cxx \
-	neptune.cxx \
-	pluto.hxx \
-	saturn.cxx \
-	star.cxx \
-	stardata.cxx \
-	uranus.cxx \
-	venus.cxx
-
-INCLUDES = -I$(top_srcdir)

simgear/ephemeris/celestialBody.cxx

@@ -24,9 +24,6 @@
 
 #include <simgear/debug/logstream.hxx>
 
-#ifdef SG_MATH_EXCEPTION_CLASH
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "celestialBody.hxx"

simgear/ephemeris/celestialBody.hxx

@@ -81,8 +81,8 @@ public:
   double getRightAscension();
   double getDeclination();
   double getMagnitude();
-  double getLon();
-  double getLat(); 
+  double getLon() const;
+  double getLat() const; 
   void updatePosition(double mjd, Star *ourSun);
 };
 
@@ -90,12 +90,12 @@ inline double CelestialBody::getRightAscension() { return rightAscension; }
 inline double CelestialBody::getDeclination() { return declination; }
 inline double CelestialBody::getMagnitude() { return magnitude; }
 
-inline double CelestialBody::getLon()
+inline double CelestialBody::getLon() const
 {
   return lonEcl;
 }
 
-inline double CelestialBody::getLat()
+inline double CelestialBody::getLat() const
 {
   return latEcl;
 }

simgear/ephemeris/ephemeris.hxx

@@ -158,6 +158,7 @@ public:
      * @return planets array
      */
     inline SGVec3d *getPlanets() { return planets; }
+    inline const SGVec3d *getPlanets() const { return planets; }
 
     /** @return the numbers of defined stars. */
     inline int getNumStars() const { return stars->getNumStars(); }
@@ -170,6 +171,7 @@ public:
      * @returns star array
      */
     inline SGVec3d *getStars() { return stars->getStars(); }
+    inline const SGVec3d *getStars() const { return stars->getStars(); }
 };
 
 

simgear/ephemeris/jupiter.cxx

@@ -22,10 +22,6 @@
  * $Id$
  **************************************************************************/
 
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "jupiter.hxx"

simgear/ephemeris/mars.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "mars.hxx"

simgear/ephemeris/mercury.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "mercury.hxx"

simgear/ephemeris/moonpos.cxx

@@ -27,9 +27,6 @@
 
 #include <simgear/debug/logstream.hxx>
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 // #include <FDM/flight.hxx>

simgear/ephemeris/saturn.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "saturn.hxx"

simgear/ephemeris/star.cxx

@@ -22,10 +22,6 @@
  * $Id$
  **************************************************************************/
 
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include <simgear/debug/logstream.hxx>

simgear/ephemeris/star.hxx

@@ -43,47 +43,47 @@ public:
     Star ();
     ~Star();
     void updatePosition(double mjd);
-    double getM();
-    double getw();
-    double getxs();
-    double getys();
-    double getye();
-    double getze();
-    double getDistance();
+    double getM() const;
+    double getw() const;
+    double getxs() const;
+    double getys() const;
+    double getye() const;
+    double getze() const;
+    double getDistance() const;
 };
 
 
-inline double Star::getM()
+inline double Star::getM() const
 {
   return M;
 }
 
-inline double Star::getw()
+inline double Star::getw() const
 {
   return w;
 }
 
-inline double Star::getxs()
+inline double Star::getxs() const
 {
   return xs;
 }
 
-inline double Star::getys()
+inline double Star::getys() const
 {
   return ys;
 }
 
-inline double Star::getye()
+inline double Star::getye() const
 {
    return ye;
 }
 
-inline double Star::getze()
+inline double Star::getze() const
 {
    return ze;
 }
 
-inline double Star::getDistance()
+inline double Star::getDistance() const
 {
   return distance;
 }

simgear/ephemeris/stardata.cxx

@@ -31,9 +31,11 @@
 #include "stardata.hxx"
 
 #if defined (_MSC_VER)
-  SG_USING_STD(getline);
+  using std::getline;
 #endif
 
+using std::string;
+
 // Constructor
 SGStarData::SGStarData( const SGPath& path )
 {

simgear/ephemeris/uranus.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "uranus.hxx"

simgear/ephemeris/venus.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "venus.hxx"

simgear/hla/CMakeLists.txt

@@ -0,0 +1,67 @@
+include (SimGearComponent)
+
+set(HLA_HEADERS
+    RTIData.hxx
+    HLAArrayDataElement.hxx
+    HLAArrayDataType.hxx
+    HLABasicDataElement.hxx
+    HLABasicDataType.hxx
+    HLADataElement.hxx
+    HLADataElementVisitor.hxx
+    HLADataType.hxx
+    HLADataTypeVisitor.hxx
+    HLAEnumeratedDataElement.hxx
+    HLAEnumeratedDataType.hxx
+    HLAFixedRecordDataElement.hxx
+    HLAFixedRecordDataType.hxx
+    HLAFederate.hxx
+    HLAInteractionClass.hxx
+    HLALocation.hxx
+    HLAObjectClass.hxx
+    HLAObjectInstance.hxx
+    HLAOMTXmlVisitor.hxx
+    HLAPropertyDataElement.hxx
+    HLARawDataElement.hxx
+    HLAVariantDataElement.hxx
+    HLAVariantDataType.hxx
+    )
+
+set(HLA_SOURCES
+    HLAArrayDataElement.cxx
+    HLAArrayDataType.cxx
+    HLABasicDataElement.cxx
+    HLABasicDataType.cxx
+    HLADataElement.cxx
+    HLADataType.cxx
+    HLADataTypeVisitor.cxx
+    HLAEnumeratedDataElement.cxx
+    HLAEnumeratedDataType.cxx
+    HLAFederate.cxx
+    HLAFixedRecordDataElement.cxx
+    HLAFixedRecordDataType.cxx
+    HLAObjectClass.cxx
+    HLAObjectInstance.cxx
+    HLAOMTXmlVisitor.cxx
+    HLAPropertyDataElement.cxx
+    HLARawDataElement.cxx
+    HLAVariantDataElement.cxx
+    HLAVariantDataType.cxx
+    )
+simgear_component(hla hla "${HLA_SOURCES}" "${HLA_HEADERS}")
+
+if(RTI_FOUND)
+  set(RTI13_SOURCES
+    RTI13ObjectClass.cxx
+    RTI13ObjectInstance.cxx
+    RTI13Federate.cxx
+    )
+  simgear_component(rti13 hla "${RTI13_SOURCES}" "")
+  set_property(TARGET sgrti13 APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
+endif()
+
+set(RTI_SOURCES
+  RTIObjectClass.cxx
+  RTIObjectInstance.cxx
+  RTIFederate.cxx
+  )
+simgear_component(rti hla "${RTI_SOURCES}" "")

simgear/hla/HLAArrayDataElement.cxx

@@ -0,0 +1,327 @@
+// Copyright (C) 2009 - 2010  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 "HLAArrayDataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLAAbstractArrayDataElement::HLAAbstractArrayDataElement(const HLAArrayDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAAbstractArrayDataElement::~HLAAbstractArrayDataElement()
+{
+}
+
+void
+HLAAbstractArrayDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLAAbstractArrayDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAAbstractArrayDataElement::decode(HLADecodeStream& stream)
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->decode(stream, *this);
+}
+
+bool
+HLAAbstractArrayDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->encode(stream, *this);
+}
+
+const HLAArrayDataType*
+HLAAbstractArrayDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAAbstractArrayDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAArrayDataType* arrayDataType = dynamic_cast<const HLAArrayDataType*>(dataType);
+    if (!arrayDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAArrayDataType: unable to set data type!");
+        return false;
+    }
+    _dataType = arrayDataType;
+    return true;
+}
+
+const HLADataType*
+HLAAbstractArrayDataElement::getElementDataType() const
+{
+    if (!_dataType.valid())
+        return 0;
+    return _dataType->getElementDataType();
+}
+
+////////////////////////////////////////////////////////////////////////
+
+HLAArrayDataElement::DataElementFactory::~DataElementFactory()
+{
+}
+
+HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) :
+    HLAAbstractArrayDataElement(dataType)
+{
+}
+
+HLAArrayDataElement::~HLAArrayDataElement()
+{
+}
+
+bool
+HLAArrayDataElement::setNumElements(unsigned size)
+{
+    unsigned oldSize = _elementVector.size();
+    if (size == oldSize)
+        return true;
+    _elementVector.resize(size);
+    for (unsigned i = oldSize; i < size; ++i)
+        _elementVector[i] = newElement(i);
+    return true;
+}
+
+bool
+HLAArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
+{
+    HLADataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->decode(stream);
+}
+
+unsigned
+HLAArrayDataElement::getNumElements() const
+{
+    return _elementVector.size();
+}
+
+bool
+HLAArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
+{
+    const HLADataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->encode(stream);
+}
+
+const HLADataElement*
+HLAArrayDataElement::getElement(unsigned index) const
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLADataElement*
+HLAArrayDataElement::getElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLADataElement*
+HLAArrayDataElement::getOrCreateElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        if (!setNumElements(index + 1))
+            return 0;
+    return _elementVector[index].get();
+}
+
+void
+HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
+{
+    unsigned oldSize = _elementVector.size();
+    if (oldSize <= index) {
+        _elementVector.resize(index + 1);
+        for (unsigned j = oldSize; j < index; ++j)
+            _elementVector[j] = newElement(j);
+    }
+    _elementVector[index] = value;
+}
+
+void
+HLAArrayDataElement::setDataElementFactory(HLAArrayDataElement::DataElementFactory* dataElementFactory)
+{
+    _dataElementFactory = dataElementFactory;
+}
+
+HLAArrayDataElement::DataElementFactory*
+HLAArrayDataElement::getDataElementFactory()
+{
+    return _dataElementFactory.get();
+}
+
+HLADataElement*
+HLAArrayDataElement::newElement(unsigned index)
+{
+    if (!_dataElementFactory.valid())
+        return 0;
+    return _dataElementFactory->createElement(*this, index);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
+    HLAAbstractArrayDataElement(0)
+{
+}
+
+HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
+{
+}
+
+bool
+HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
+    if (!arrayDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
+        return false;
+    }
+    const HLAVariantDataType* variantDataType = arrayDataType->getElementDataType()->toVariantDataType();
+    if (!variantDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type: arrayDataTypes element data type is no a variant data type!");
+        return false;
+    }
+    _dataType = arrayDataType;
+    return true;
+}
+
+bool
+HLAVariantArrayDataElement::setNumElements(unsigned size)
+{
+    unsigned oldSize = _elementVector.size();
+    if (size == oldSize)
+        return true;
+    _elementVector.resize(size);
+    for (unsigned i = oldSize; i < size; ++i)
+        _elementVector[i] = newElement();
+    return true;
+}
+
+bool
+HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
+{
+    HLAVariantDataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->decode(stream);
+}
+
+unsigned
+HLAVariantArrayDataElement::getNumElements() const
+{
+    return _elementVector.size();
+}
+
+bool
+HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
+{
+    const HLADataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->encode(stream);
+}
+
+const HLAVariantDataElement*
+HLAVariantArrayDataElement::getElement(unsigned index) const
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLAVariantDataElement*
+HLAVariantArrayDataElement::getElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLAVariantDataElement*
+HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        if (!setNumElements(index + 1))
+            return 0;
+    return _elementVector[index].get();
+}
+
+void
+HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* value)
+{
+    unsigned oldSize = _elementVector.size();
+    if (oldSize <= index) {
+        _elementVector.resize(index + 1);
+        for (unsigned j = oldSize; j < index; ++j)
+            _elementVector[j] = newElement();
+    }
+    _elementVector[index] = value;
+}
+
+void
+HLAVariantArrayDataElement::setAlternativeDataElementFactory(HLAVariantArrayDataElement::AlternativeDataElementFactory* alternativeDataElementFactory)
+{
+    _alternativeDataElementFactory = alternativeDataElementFactory;
+}
+
+HLAVariantArrayDataElement::AlternativeDataElementFactory*
+HLAVariantArrayDataElement::getAlternativeDataElementFactory()
+{
+    return _alternativeDataElementFactory.get();
+}
+
+HLAVariantDataElement*
+HLAVariantArrayDataElement::newElement()
+{
+    const HLAArrayDataType* arrayDataType = getDataType();
+    if (!arrayDataType)
+        return 0;
+    const HLADataType* elementDataType = arrayDataType->getElementDataType();
+    if (!elementDataType)
+        return 0;
+    const HLAVariantDataType* variantDataType = elementDataType->toVariantDataType();
+    if (!variantDataType)
+        return 0;
+    HLAVariantDataElement* variantDataElement = new HLAVariantDataElement(variantDataType);
+    variantDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
+    return variantDataElement;
+}
+
+}

simgear/hla/HLAArrayDataElement.hxx

@@ -0,0 +1,532 @@
+// Copyright (C) 2009 - 2010  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 HLAArrayDataElement_hxx
+#define HLAArrayDataElement_hxx
+
+#include <string>
+#include <vector>
+#include <simgear/math/SGMath.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLADataElement.hxx"
+#include "HLAVariantDataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+class HLAAbstractArrayDataElement : public HLADataElement {
+public:
+    HLAAbstractArrayDataElement(const HLAArrayDataType* dataType);
+    virtual ~HLAAbstractArrayDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAArrayDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+
+    const HLADataType* getElementDataType() const;
+
+    virtual bool setNumElements(unsigned count) = 0;
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i) = 0;
+
+    virtual unsigned getNumElements() const = 0;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const = 0;
+
+protected:
+    SGSharedPtr<const HLAArrayDataType> _dataType;
+};
+
+class HLAArrayDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAArrayDataElement(const HLAArrayDataType* dataType = 0);
+    virtual ~HLAArrayDataElement();
+
+    virtual bool setNumElements(unsigned size);
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+    virtual unsigned getNumElements() const;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
+
+    const HLADataElement* getElement(unsigned index) const;
+    HLADataElement* getElement(unsigned index);
+    HLADataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned i, HLADataElement* value);
+
+    class DataElementFactory : public SGReferenced {
+    public:
+        virtual ~DataElementFactory();
+        virtual HLADataElement* createElement(const HLAArrayDataElement&, unsigned) = 0;
+    };
+
+    void setDataElementFactory(DataElementFactory* dataElementFactory);
+    DataElementFactory* getDataElementFactory();
+
+private:
+    HLADataElement* newElement(unsigned index);
+
+    typedef std::vector<SGSharedPtr<HLADataElement> > ElementVector;
+    ElementVector _elementVector;
+
+    SGSharedPtr<DataElementFactory> _dataElementFactory;
+};
+
+// Holds an array of variants.
+// Factors out common code for that use case.
+class HLAVariantArrayDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVariantArrayDataElement();
+    virtual ~HLAVariantArrayDataElement();
+
+    // Overwrite this from the abstract class, need some more checks here
+    virtual bool setDataType(const HLADataType* dataType);
+
+    virtual bool setNumElements(unsigned size);
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+    virtual unsigned getNumElements() const;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
+
+    const HLAVariantDataElement* getElement(unsigned index) const;
+    HLAVariantDataElement* getElement(unsigned index);
+    HLAVariantDataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned index, HLAVariantDataElement* value);
+
+    typedef HLAVariantDataElement::DataElementFactory AlternativeDataElementFactory;
+
+    void setAlternativeDataElementFactory(AlternativeDataElementFactory* alternativeDataElementFactory);
+    AlternativeDataElementFactory* getAlternativeDataElementFactory();
+
+private:
+    HLAVariantDataElement* newElement();
+
+    typedef std::vector<SGSharedPtr<HLAVariantDataElement> > ElementVector;
+    ElementVector _elementVector;
+
+    SGSharedPtr<AlternativeDataElementFactory> _alternativeDataElementFactory;
+};
+
+class HLAStringDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAStringDataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType)
+    {}
+    HLAStringDataElement(const HLAArrayDataType* dataType, const std::string& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const std::string& getValue() const
+    { return _value; }
+    void setValue(const std::string& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        _value.resize(count);
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        HLATemplateDecodeVisitor<std::string::value_type> visitor(stream);
+        getElementDataType()->accept(visitor);
+        _value[i] = visitor.getValue();
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return _value.size();
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        HLATemplateEncodeVisitor<std::string::value_type> visitor(stream, _value[i]);
+        getElementDataType()->accept(visitor);
+        return true;
+    }
+
+private:
+    std::string _value;
+};
+
+class HLAStringData {
+public:
+    HLAStringData() :
+        _value(new HLAStringDataElement(0))
+    { }
+    HLAStringData(const std::string& value) :
+        _value(new HLAStringDataElement(0))
+    { _value->setValue(value); }
+
+    operator const std::string&() const
+    { return _value->getValue(); }
+    HLAStringData& operator=(const std::string& value)
+    { _value->setValue(value); return *this; }
+
+    const std::string& getValue() const
+    { return _value->getValue(); }
+    void setValue(const std::string& value)
+    { _value->setValue(value); }
+
+    const HLAStringDataElement* getDataElement() const
+    { return _value.get(); }
+    HLAStringDataElement* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAStringDataElement> _value;
+};
+
+template<typename T>
+class HLAVec2DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec2DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec2<T>::zeros())
+    {}
+    HLAVec2DataElement(const HLAArrayDataType* dataType, const SGVec2<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec2<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec2<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 2; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 2) {
+            HLATemplateDecodeVisitor<typename SGVec2<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 2;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 2) {
+            HLATemplateEncodeVisitor<typename SGVec2<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec2<T> _value;
+};
+
+template<typename T>
+class HLAVec2Data {
+public:
+    HLAVec2Data() :
+        _value(new HLAVec2DataElement<T>(0))
+    { }
+    HLAVec2Data(const SGVec2<T>& value) :
+        _value(new HLAVec2DataElement<T>(0, value))
+    { }
+
+    operator const SGVec2<T>&() const
+    { return _value->getValue(); }
+    HLAVec2Data& operator=(const SGVec2<T>& value)
+    { _value->setValue(value); return *this; }
+
+    const SGVec2<T>& getValue() const
+    { return _value->getValue(); }
+    void setValue(const SGVec2<T>& value)
+    { _value->setValue(value); }
+
+    const HLAVec2DataElement<T>* getDataElement() const
+    { return _value.get(); }
+    HLAVec2DataElement<T>* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAVec2DataElement<T> > _value;
+};
+
+typedef HLAVec2Data<float> HLAVec2fData;
+typedef HLAVec2Data<double> HLAVec2dData;
+
+template<typename T>
+class HLAVec3DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec3DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec3<T>::zeros())
+    {}
+    HLAVec3DataElement(const HLAArrayDataType* dataType, const SGVec3<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec3<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec3<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 3; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 3) {
+            HLATemplateDecodeVisitor<typename SGVec3<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 3;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 3) {
+            HLATemplateEncodeVisitor<typename SGVec3<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec3<T> _value;
+};
+
+template<typename T>
+class HLAVec3Data {
+public:
+    HLAVec3Data() :
+        _value(new HLAVec3DataElement<T>(0))
+    { }
+    HLAVec3Data(const SGVec3<T>& value) :
+        _value(new HLAVec3DataElement<T>(0, value))
+    { }
+
+    operator const SGVec3<T>&() const
+    { return _value->getValue(); }
+    HLAVec3Data& operator=(const SGVec3<T>& value)
+    { _value->setValue(value); return *this; }
+
+    const SGVec3<T>& getValue() const
+    { return _value->getValue(); }
+    void setValue(const SGVec3<T>& value)
+    { _value->setValue(value); }
+
+    const HLAVec3DataElement<T>* getDataElement() const
+    { return _value.get(); }
+    HLAVec3DataElement<T>* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAVec3DataElement<T> > _value;
+};
+
+typedef HLAVec3Data<float> HLAVec3fData;
+typedef HLAVec3Data<double> HLAVec3dData;
+
+template<typename T>
+class HLAVec4DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec4DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec4<T>::zeros())
+    {}
+    HLAVec4DataElement(const HLAArrayDataType* dataType, const SGVec4<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec4<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec4<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 4; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 4) {
+            HLATemplateDecodeVisitor<typename SGVec4<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 4;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 4) {
+            HLATemplateEncodeVisitor<typename SGVec4<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec4<T> _value;
+};
+
+template<typename T>
+class HLAVec4Data {
+public:
+    HLAVec4Data() :
+        _value(new HLAVec4DataElement<T>(0))
+    { }
+    HLAVec4Data(const SGVec4<T>& value) :
+        _value(new HLAVec4DataElement<T>(0, value))
+    { }
+
+    operator const SGVec4<T>&() const
+    { return _value->getValue(); }
+    HLAVec4Data& operator=(const SGVec4<T>& value)
+    { _value->setValue(value); return *this; }
+
+    const SGVec4<T>& getValue() const
+    { return _value->getValue(); }
+    void setValue(const SGVec4<T>& value)
+    { _value->setValue(value); }
+
+    const HLAVec4DataElement<T>* getDataElement() const
+    { return _value.get(); }
+    HLAVec4DataElement<T>* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAVec4DataElement<T> > _value;
+};
+
+typedef HLAVec4Data<float> HLAVec4fData;
+typedef HLAVec4Data<double> HLAVec4dData;
+
+template<typename T>
+class HLAQuatDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAQuatDataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGQuat<T>::zeros())
+    {}
+    HLAQuatDataElement(const HLAArrayDataType* dataType, const SGQuat<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGQuat<T>& getValue() const
+    { return _value; }
+    void setValue(const SGQuat<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 4; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 4) {
+            HLATemplateDecodeVisitor<typename SGQuat<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 4;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 4) {
+            HLATemplateEncodeVisitor<typename SGQuat<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGQuat<T> _value;
+};
+
+}
+
+#endif

simgear/hla/HLAArrayDataType.cxx

@@ -0,0 +1,172 @@
+// Copyright (C) 2009 - 2011  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 "HLAArrayDataType.hxx"
+
+#include "HLAArrayDataElement.hxx"
+
+namespace simgear {
+
+HLAArrayDataType::HLAArrayDataType(const std::string& name) :
+    HLADataType(name),
+    _isOpaque(false),
+    _isString(false)
+{
+}
+
+HLAArrayDataType::~HLAArrayDataType()
+{
+}
+
+void
+HLAArrayDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLAArrayDataType*
+HLAArrayDataType::toArrayDataType() const
+{
+    return this;
+}
+
+void
+HLAArrayDataType::setElementDataType(const HLADataType* elementDataType)
+{
+    // FIXME this only works if we do not reset the alignment to something smaller
+    if (getAlignment() < elementDataType->getAlignment())
+        setAlignment(elementDataType->getAlignment());
+    _elementDataType = elementDataType;
+}
+
+void
+HLAArrayDataType::setIsOpaque(bool isOpaque)
+{
+    _isOpaque = isOpaque;
+}
+
+void
+HLAArrayDataType::setIsString(bool isString)
+{
+    _isString = isString;
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+
+HLAFixedArrayDataType::HLAFixedArrayDataType(const std::string& name) :
+    HLAArrayDataType(name)
+{
+}
+
+HLAFixedArrayDataType::~HLAFixedArrayDataType()
+{
+}
+
+void
+HLAFixedArrayDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAFixedArrayDataType::decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numElements = getNumElements();
+    if (!value.setNumElements(numElements))
+        return false;
+    for (unsigned i = 0; i < numElements; ++i)
+        if (!value.decodeElement(stream, i))
+            return false;
+    return true;
+}
+
+bool
+HLAFixedArrayDataType::encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numElementsType = getNumElements();
+    unsigned numElementsValue = value.getNumElements();
+    unsigned numElements = SGMisc<unsigned>::min(numElementsType, numElementsValue);
+    unsigned i = 0;
+    for (; i < numElements; ++i)
+        if (!value.encodeElement(stream, i))
+            return false;
+    for (; i < numElementsType; ++i) {
+        HLADataTypeEncodeVisitor visitor(stream);
+        getElementDataType()->accept(visitor);
+    }
+    return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+
+HLAVariableArrayDataType::HLAVariableArrayDataType(const std::string& name) :
+    HLAArrayDataType(name)
+{
+    setSizeDataType(new HLAUInt32BEDataType);
+}
+
+HLAVariableArrayDataType::~HLAVariableArrayDataType()
+{
+}
+
+void
+HLAVariableArrayDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAVariableArrayDataType::decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    HLATemplateDecodeVisitor<unsigned> numElementsVisitor(stream);
+    getSizeDataType()->accept(numElementsVisitor);
+    unsigned numElements = numElementsVisitor.getValue();
+    if (!value.setNumElements(numElements))
+        return false;
+    for (unsigned i = 0; i < numElements; ++i)
+        if (!value.decodeElement(stream, i))
+            return false;
+    return true;
+}
+
+bool
+HLAVariableArrayDataType::encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numElements = value.getNumElements();
+    HLATemplateEncodeVisitor<unsigned> numElementsVisitor(stream, numElements);
+    getSizeDataType()->accept(numElementsVisitor);
+    for (unsigned i = 0; i < numElements; ++i)
+        if (!value.encodeElement(stream, i))
+            return false;
+    return true;
+}
+
+void
+HLAVariableArrayDataType::setSizeDataType(const HLADataType* sizeDataType)
+{
+    // FIXME this only works if we do not reset the alignment to something smaller
+    if (getAlignment() < sizeDataType->getAlignment())
+        setAlignment(sizeDataType->getAlignment());
+    _sizeDataType = sizeDataType;
+    // setAlignment(SGMisc<unsigned>::max(_sizeDataType->getAlignment(), _elementDataType->getAlignment());
+}
+
+} // namespace simgear

simgear/hla/HLAArrayDataType.hxx

@@ -0,0 +1,98 @@
+// Copyright (C) 2009 - 2011  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 HLAArrayDataType_hxx
+#define HLAArrayDataType_hxx
+
+#include <string>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractArrayDataElement;
+
+class HLAArrayDataType : public HLADataType {
+public:
+    HLAArrayDataType(const std::string& name = "HLAArrayDataType");
+    virtual ~HLAArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLAArrayDataType* toArrayDataType() const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const = 0;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const = 0;
+
+    void setElementDataType(const HLADataType* elementDataType);
+    const HLADataType* getElementDataType() const
+    { return _elementDataType.get(); }
+
+    void setIsOpaque(bool isOpaque);
+    bool getIsOpaque() const
+    { return _isOpaque; }
+
+    void setIsString(bool isString);
+    bool getIsString() const
+    { return _isString; }
+
+private:
+    SGSharedPtr<const HLADataType> _elementDataType;
+    bool _isOpaque;
+    bool _isString;
+};
+
+class HLAFixedArrayDataType : public HLAArrayDataType {
+public:
+    HLAFixedArrayDataType(const std::string& name = "HLAFixedArrayDataType");
+    virtual ~HLAFixedArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
+
+    void setNumElements(unsigned numElements)
+    { _numElements = numElements; }
+    unsigned getNumElements() const
+    { return _numElements; }
+
+private:
+    unsigned _numElements;
+};
+
+class HLAVariableArrayDataType : public HLAArrayDataType {
+public:
+    HLAVariableArrayDataType(const std::string& name = "HLAVariableArrayDataType");
+    virtual ~HLAVariableArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
+
+    void setSizeDataType(const HLADataType* sizeDataType);
+    const HLADataType* getSizeDataType() const
+    { return _sizeDataType.get(); }
+
+private:
+    SGSharedPtr<const HLADataType> _sizeDataType;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLABasicDataElement.cxx

@@ -0,0 +1,145 @@
+// Copyright (C) 2009 - 2010  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 "HLABasicDataElement.hxx"
+
+#include "HLADataElementVisitor.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLABasicDataElement::HLABasicDataElement(const HLABasicDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLABasicDataElement::~HLABasicDataElement()
+{
+}
+
+void
+HLABasicDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLABasicDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLABasicDataType*
+HLABasicDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLABasicDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLABasicDataType* scalarDataType = dynamic_cast<const HLABasicDataType*>(dataType);
+    if (!scalarDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLABasicDataType: unable to set data type!");
+        return false;
+    }
+    setDataType(scalarDataType);
+    return true;
+}
+
+void
+HLABasicDataElement::setDataType(const HLABasicDataType* dataType)
+{
+    _dataType = dataType;
+}
+
+#define IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(type, ctype)                                       \
+HLAAbstract##type##DataElement::HLAAbstract##type##DataElement(const HLABasicDataType* dataType) :\
+    HLABasicDataElement(dataType)                                                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+HLAAbstract##type##DataElement::~HLAAbstract##type##DataElement()                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+bool                                                                                              \
+HLAAbstract##type##DataElement::encode(HLAEncodeStream& stream) const                             \
+{                                                                                                 \
+    if (!_dataType.valid())                                                                       \
+        return false;                                                                             \
+    HLATemplateEncodeVisitor<ctype> visitor(stream, getValue());                                  \
+    _dataType->accept(visitor);                                                                   \
+    return true;                                                                                  \
+}                                                                                                 \
+                                                                                                  \
+bool                                                                                              \
+HLAAbstract##type##DataElement::decode(HLADecodeStream& stream)                                   \
+{                                                                                                 \
+    if (!_dataType.valid())                                                                       \
+        return false;                                                                             \
+    HLATemplateDecodeVisitor<ctype> visitor(stream);                                              \
+    _dataType->accept(visitor);                                                                   \
+    setValue(visitor.getValue());                                                                 \
+    return true;                                                                                  \
+}                                                                                                 \
+                                                                                                  \
+HLA##type##DataElement::HLA##type##DataElement(const HLABasicDataType* dataType) :                \
+    HLAAbstract##type##DataElement(dataType),                                                     \
+    _value(0)                                                                                     \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+HLA##type##DataElement::HLA##type##DataElement(const HLABasicDataType* dataType,                  \
+                                               const ctype& value) :                              \
+    HLAAbstract##type##DataElement(dataType),                                                     \
+    _value(value)                                                                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+HLA##type##DataElement::~HLA##type##DataElement()                                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+ctype                                                                                             \
+HLA##type##DataElement::getValue() const                                                          \
+{                                                                                                 \
+    return _value;                                                                                \
+}                                                                                                 \
+                                                                                                  \
+void                                                                                              \
+HLA##type##DataElement::setValue(ctype value)                                                     \
+{                                                                                                 \
+    _value = value;                                                                               \
+}
+
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(WChar, wchar_t);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(SChar, signed char);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UChar, unsigned char);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Short, short);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UShort, unsigned short);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Int, int);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UInt, unsigned int);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Long, long);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(ULong, unsigned long);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Float, float);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Double, double);
+
+#undef IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT
+
+}

simgear/hla/HLABasicDataElement.hxx

@@ -0,0 +1,115 @@
+// Copyright (C) 2009 - 2010  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 HLABasicDataElement_hxx
+#define HLABasicDataElement_hxx
+
+#include "HLABasicDataType.hxx"
+#include "HLADataElement.hxx"
+
+namespace simgear {
+
+class HLABasicDataElement : public HLADataElement {
+public:
+    HLABasicDataElement(const HLABasicDataType* dataType);
+    virtual ~HLABasicDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool encode(HLAEncodeStream& stream) const = 0;
+    virtual bool decode(HLADecodeStream& stream) = 0;
+
+    virtual const HLABasicDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLABasicDataType* dataType);
+
+protected:
+    SGSharedPtr<const HLABasicDataType> _dataType;
+};
+
+#define TYPED_HLA_BASIC_DATA_ELEMENT(type, ctype)                             \
+class HLAAbstract##type##DataElement : public HLABasicDataElement {           \
+public:                                                                       \
+    HLAAbstract##type##DataElement(const HLABasicDataType* dataType = 0);     \
+    virtual ~HLAAbstract##type##DataElement();                                \
+                                                                              \
+    virtual bool encode(HLAEncodeStream& stream) const;                       \
+    virtual bool decode(HLADecodeStream& stream);                             \
+                                                                              \
+    virtual ctype getValue() const = 0;                                       \
+    virtual void setValue(ctype) = 0;                                         \
+};                                                                            \
+class HLA##type##DataElement : public HLAAbstract##type##DataElement {        \
+public:                                                                       \
+    HLA##type##DataElement(const HLABasicDataType* dataType = 0);             \
+    HLA##type##DataElement(const HLABasicDataType* dataType,                  \
+                           const ctype& value);                               \
+    virtual ~HLA##type##DataElement();                                        \
+    virtual ctype getValue() const;                                           \
+    virtual void setValue(ctype value);                                       \
+private:                                                                      \
+    ctype _value;                                                             \
+};                                                                            \
+class HLA##type##Data {                                                       \
+public:                                                                       \
+    HLA##type##Data() :                                                       \
+        _value(new HLA##type##DataElement(0))                                 \
+    { }                                                                       \
+    HLA##type##Data(const ctype& value) :                                     \
+        _value(new HLA##type##DataElement(0, value))                          \
+    { }                                                                       \
+    operator ctype() const                                                    \
+    { return _value->getValue(); }                                            \
+    HLA##type##Data& operator=(const ctype& value)                            \
+    { _value->setValue(value); return *this; }                                \
+    ctype getValue() const                                                    \
+    { return _value->getValue(); }                                            \
+    void setValue(const ctype& value)                                         \
+    { _value->setValue(value); }                                              \
+    const HLA##type##DataElement* getDataElement() const                      \
+    { return _value.get(); }                                                  \
+    HLA##type##DataElement* getDataElement()                                  \
+    { return _value.get(); }                                                  \
+    const HLABasicDataType* getDataType() const                               \
+    { return _value->getDataType(); }                                         \
+    void setDataType(const HLABasicDataType* dataType)                        \
+    { _value->setDataType(dataType); }                                        \
+                                                                              \
+private:                                                                      \
+    SGSharedPtr<HLA##type##DataElement> _value;                               \
+};
+
+
+TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
+TYPED_HLA_BASIC_DATA_ELEMENT(WChar, wchar_t);
+TYPED_HLA_BASIC_DATA_ELEMENT(SChar, signed char);
+TYPED_HLA_BASIC_DATA_ELEMENT(UChar, unsigned char);
+TYPED_HLA_BASIC_DATA_ELEMENT(Short, short);
+TYPED_HLA_BASIC_DATA_ELEMENT(UShort, unsigned short);
+TYPED_HLA_BASIC_DATA_ELEMENT(Int, int);
+TYPED_HLA_BASIC_DATA_ELEMENT(UInt, unsigned int);
+TYPED_HLA_BASIC_DATA_ELEMENT(Long, long);
+TYPED_HLA_BASIC_DATA_ELEMENT(ULong, unsigned long);
+TYPED_HLA_BASIC_DATA_ELEMENT(Float, float);
+TYPED_HLA_BASIC_DATA_ELEMENT(Double, double);
+
+#undef TYPED_HLA_BASIC_DATA_ELEMENT
+
+}
+
+#endif

simgear/hla/HLABasicDataType.cxx

@@ -0,0 +1,170 @@
+// Copyright (C) 2009 - 2010  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 "HLABasicDataType.hxx"
+
+#include "HLADataType.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLABasicDataType::HLABasicDataType(const std::string& name) :
+    HLADataType(name)
+{
+}
+
+HLABasicDataType::~HLABasicDataType()
+{
+}
+
+void
+HLABasicDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLABasicDataType*
+HLABasicDataType::toBasicDataType() const
+{
+    return this;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+HLAInt8DataType::HLAInt8DataType(const std::string& name) :
+    HLABasicDataType(name)
+{
+    setAlignment(sizeof(int8_t));
+}
+
+HLAInt8DataType::~HLAInt8DataType()
+{
+}
+
+void
+HLAInt8DataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+HLAUInt8DataType::HLAUInt8DataType(const std::string& name) :
+    HLABasicDataType(name)
+{
+    setAlignment(sizeof(uint8_t));
+}
+
+HLAUInt8DataType::~HLAUInt8DataType()
+{
+}
+
+void
+HLAUInt8DataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#define BASIC_DATATYPE_IMPLEMENTATION(type, name)                       \
+HLA##name##DataType::HLA##name##DataType(const std::string& name) :     \
+    HLABasicDataType(name)                                              \
+{                                                                       \
+    setAlignment(sizeof(type));                                         \
+}                                                                       \
+                                                                        \
+HLA##name##DataType::~HLA##name##DataType()                             \
+{                                                                       \
+}                                                                       \
+                                                                        \
+void                                                                    \
+HLA##name##DataType::accept(HLADataTypeVisitor& visitor) const          \
+{                                                                       \
+    visitor.apply(*this);                                               \
+}                                                                       \
+                                                                        \
+                                                                        \
+                                                                        \
+HLA##name##LEDataType::HLA##name##LEDataType(const std::string& name) : \
+    HLA##name##DataType(name)                                           \
+{                                                                       \
+}                                                                       \
+                                                                        \
+HLA##name##LEDataType::~HLA##name##LEDataType()                         \
+{                                                                       \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##LEDataType::decode(HLADecodeStream& stream,                  \
+                              type& value) const                        \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.decode##name##LE(value);                              \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##LEDataType::encode(HLAEncodeStream& stream,                  \
+                              const type& value) const                  \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.encode##name##LE(value);                              \
+}                                                                       \
+                                                                        \
+                                                                        \
+                                                                        \
+HLA##name##BEDataType::HLA##name##BEDataType(const std::string& name) : \
+    HLA##name##DataType(name)                                           \
+{                                                                       \
+}                                                                       \
+                                                                        \
+HLA##name##BEDataType::~HLA##name##BEDataType()                         \
+{                                                                       \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##BEDataType::decode(HLADecodeStream& stream,                  \
+                              type& value) const                        \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.decode##name##BE(value);                              \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##BEDataType::encode(HLAEncodeStream& stream,                  \
+                              const type& value) const                  \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.encode##name##BE(value);                              \
+}
+
+BASIC_DATATYPE_IMPLEMENTATION(int16_t, Int16)
+BASIC_DATATYPE_IMPLEMENTATION(uint16_t, UInt16)
+BASIC_DATATYPE_IMPLEMENTATION(int32_t, Int32)
+BASIC_DATATYPE_IMPLEMENTATION(uint32_t, UInt32)
+BASIC_DATATYPE_IMPLEMENTATION(int64_t, Int64)
+BASIC_DATATYPE_IMPLEMENTATION(uint64_t, UInt64)
+BASIC_DATATYPE_IMPLEMENTATION(float, Float32)
+BASIC_DATATYPE_IMPLEMENTATION(double, Float64)
+
+#undef BASIC_DATATYPE_IMPLEMENTATION
+
+} // namespace simgear

simgear/hla/HLABasicDataType.hxx

@@ -0,0 +1,155 @@
+// Copyright (C) 2009 - 2010  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 HLABasicDataType_hxx
+#define HLABasicDataType_hxx
+
+#include <string>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLABasicDataType : public HLADataType {
+public:
+    virtual ~HLABasicDataType();
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLABasicDataType* toBasicDataType() const;
+
+protected:
+    HLABasicDataType(const std::string& name);
+};
+
+class HLAInt8DataType : public HLABasicDataType {
+public:
+    HLAInt8DataType(const std::string& name = "HLAInt8DataType");
+    virtual ~HLAInt8DataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    bool skip(HLADecodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool skip(HLAEncodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool decode(HLADecodeStream& stream, int8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.decodeInt8(value);
+    }
+    bool encode(HLAEncodeStream& stream, const int8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.encodeInt8(value);
+    }
+};
+
+class HLAUInt8DataType : public HLABasicDataType {
+public:
+    HLAUInt8DataType(const std::string& name = "HLAUInt8DataType");
+    virtual ~HLAUInt8DataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    bool skip(HLADecodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool skip(HLAEncodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool decode(HLADecodeStream& stream, uint8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.decodeUInt8(value);
+    }
+    bool encode(HLAEncodeStream& stream, const uint8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.encodeUInt8(value);
+    }
+};
+
+#define BASIC_DATATYPE_IMPLEMENTATION(type, name)                          \
+class HLA##name##DataType : public HLABasicDataType {                      \
+public:                                                                    \
+ virtual ~HLA##name##DataType();                                           \
+                                                                           \
+ virtual void accept(HLADataTypeVisitor& visitor) const;                   \
+                                                                           \
+ bool skip(HLADecodeStream& stream) const                                  \
+ {                                                                         \
+   if (!stream.alignOffsetForSize(getAlignment()))                         \
+     return false;                                                         \
+   return stream.skip(sizeof(type));                                       \
+ }                                                                         \
+ bool skip(HLAEncodeStream& stream) const                                  \
+ {                                                                         \
+   if (!stream.alignOffsetForSize(getAlignment()))                         \
+     return false;                                                         \
+   return stream.skip(sizeof(type));                                       \
+ }                                                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const = 0;      \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const = 0;\
+protected:                                                                 \
+ HLA##name##DataType(const std::string& name);                             \
+};                                                                         \
+class HLA##name##LEDataType : public HLA##name##DataType {                 \
+public:                                                                    \
+ HLA##name##LEDataType(const std::string& name = "HLA" #name "LEDataType");\
+ virtual ~HLA##name##LEDataType();                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const;          \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const;    \
+};                                                                         \
+class HLA##name##BEDataType : public HLA##name##DataType {                 \
+public:                                                                    \
+ HLA##name##BEDataType(const std::string& name = "HLA" #name "BEDataType");\
+ virtual ~HLA##name##BEDataType();                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const;          \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const;    \
+};
+
+BASIC_DATATYPE_IMPLEMENTATION(int16_t, Int16)
+BASIC_DATATYPE_IMPLEMENTATION(uint16_t, UInt16)
+BASIC_DATATYPE_IMPLEMENTATION(int32_t, Int32)
+BASIC_DATATYPE_IMPLEMENTATION(uint32_t, UInt32)
+BASIC_DATATYPE_IMPLEMENTATION(int64_t, Int64)
+BASIC_DATATYPE_IMPLEMENTATION(uint64_t, UInt64)
+BASIC_DATATYPE_IMPLEMENTATION(float, Float32)
+BASIC_DATATYPE_IMPLEMENTATION(double, Float64)
+
+#undef BASIC_DATATYPE_IMPLEMENTATION
+
+} // namespace simgear
+
+#endif

simgear/hla/HLADataElement.cxx

@@ -0,0 +1,201 @@
+// Copyright (C) 2009 - 2010  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 "HLADataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLADataElement::PathElement::Data::~Data()
+{
+}
+
+const HLADataElement::PathElement::FieldData*
+HLADataElement::PathElement::Data::toFieldData() const
+{
+    return 0;
+}
+
+const HLADataElement::PathElement::IndexData*
+HLADataElement::PathElement::Data::toIndexData() const
+{
+    return 0;
+}
+
+HLADataElement::PathElement::FieldData::FieldData(const std::string& name) :
+    _name(name)
+{
+}
+
+HLADataElement::PathElement::FieldData::~FieldData()
+{
+}
+
+const HLADataElement::PathElement::FieldData*
+HLADataElement::PathElement::FieldData::toFieldData() const
+{
+    return this;
+}
+
+bool
+HLADataElement::PathElement::FieldData::less(const Data* data) const
+{
+    const FieldData* fieldData = data->toFieldData();
+    // IndexData is allways smaller than FieldData
+    if (!fieldData)
+        return false;
+    return _name < fieldData->_name;
+}
+
+bool
+HLADataElement::PathElement::FieldData::equal(const Data* data) const
+{
+    const FieldData* fieldData = data->toFieldData();
+    // IndexData is allways smaller than FieldData
+    if (!fieldData)
+        return false;
+    return _name == fieldData->_name;
+}
+
+void
+HLADataElement::PathElement::FieldData::append(std::string& s) const
+{
+    s.append(1, std::string::value_type('.'));
+    s.append(_name);
+}
+
+HLADataElement::PathElement::IndexData::IndexData(unsigned index) :
+    _index(index)
+{
+}
+
+HLADataElement::PathElement::IndexData::~IndexData()
+{
+}
+
+const HLADataElement::PathElement::IndexData*
+HLADataElement::PathElement::IndexData::toIndexData() const
+{
+    return this;
+}
+
+bool
+HLADataElement::PathElement::IndexData::less(const Data* data) const
+{
+    const IndexData* indexData = data->toIndexData();
+    // IndexData is allways smaller than FieldData
+    if (!indexData)
+        return true;
+    return _index < indexData->_index;
+}
+
+bool
+HLADataElement::PathElement::IndexData::equal(const Data* data) const
+{
+    const IndexData* indexData = data->toIndexData();
+    // IndexData is allways smaller than FieldData
+    if (!indexData)
+        return false;
+    return _index == indexData->_index;
+}
+
+void
+HLADataElement::PathElement::IndexData::append(std::string& s) const
+{
+    s.append(1, std::string::value_type('['));
+    unsigned value = _index;
+    do {
+        s.append(1, std::string::value_type('0' + value % 10));
+    } while (value /= 10);
+    s.append(1, std::string::value_type(']'));
+}
+
+HLADataElement::~HLADataElement()
+{
+}
+
+void
+HLADataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLADataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+std::string
+HLADataElement::toString(const Path& path)
+{
+    std::string s;
+    for (Path::const_iterator i = path.begin(); i != path.end(); ++i)
+        i->append(s);
+    return s;
+}
+
+HLADataElement::AttributePathPair
+HLADataElement::toAttributePathPair(const std::string& s)
+{
+    Path path;
+    // Skip the initial attribute name if given
+    std::string::size_type i = s.find_first_of("[.");
+    std::string attribute = s.substr(0, i);
+    while (i < s.size()) {
+        if (s[i] == '[') {
+            ++i;
+            unsigned index = 0;
+            while (i < s.size()) {
+                if (s[i] == ']')
+                    break;
+                unsigned v = s[i] - '0';
+                // Error, no number
+                if (10 <= v) {
+                    SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid character in array subscript for \""
+                           << s << "\" at \"" << attribute << toString(path) << "\"!");
+                    return AttributePathPair();
+                }
+                index *= 10;
+                index += v;
+                ++i;
+            }
+            path.push_back(index);
+            ++i;
+            continue;
+        }
+        if (s[i] == '.') {
+            // Error, . cannot be last
+            if (s.size() <= ++i) {
+                SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid terminating '.' for \""
+                       << s << "\"!");
+                return AttributePathPair();
+            }
+            std::string::size_type e = s.find_first_of("[.", i);
+            path.push_back(s.substr(i, e - i));
+            i = e;
+            continue;
+        }
+    }
+
+    return AttributePathPair(attribute, path);
+}
+
+}

simgear/hla/HLADataElement.hxx

@@ -0,0 +1,223 @@
+// Copyright (C) 2009 - 2011  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 HLADataElement_hxx
+#define HLADataElement_hxx
+
+#include <list>
+#include <map>
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/timing/timestamp.hxx>
+#include "RTIData.hxx"
+#include "HLADataType.hxx"
+
+class SGTimeStamp;
+
+namespace simgear {
+
+class HLADataElementVisitor;
+class HLAConstDataElementVisitor;
+
+class HLADataElement : public SGReferenced {
+public:
+    virtual ~HLADataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor) = 0;
+    virtual void accept(HLAConstDataElementVisitor& visitor) const = 0;
+
+    virtual bool encode(HLAEncodeStream& stream) const = 0;
+    virtual bool decode(HLADecodeStream& stream) = 0;
+
+    virtual const HLADataType* getDataType() const = 0;
+    virtual bool setDataType(const HLADataType* dataType) = 0;
+
+    // Container for the timestamp the originating attribute was last updated for
+    // class TimeStamp : public SGReferenced {
+    // public:
+    //     const SGTimeStamp& getTimeStamp() const
+    //     { return _timeStamp; }
+    //     void setTimeStamp(const SGTimeStamp& timeStamp)
+    //     { _timeStamp = timeStamp; }
+    // private:
+    //     SGTimeStamp _timeStamp;
+    // };
+
+    // const TimeStamp* getTimeStamp() const
+    // { return _timeStamp.get(); }
+    // void setTimeStamp(const TimeStamp* timeStamp)
+    // { _timeStamp = timeStamp; }
+
+    // struct ChangeCount : public SGReferenced {
+    //     ChangeCount() : _value(0) {}
+    //     unsigned _value;
+    // };
+    // SGSharedPtr<ChangeCount> _changeCount;
+    // unsigned getChangeCount() const
+    // {
+    //     // If we don't have return allways the same
+    //     if (!_changeCount.valid())
+    //         return 0;
+    //     return _changeCount->_value;
+    // }
+
+    /// HLADataElements could be identified by path
+    /// These paths are composed of structure field names and array indices in the
+    /// order they appear while walking to the data element.
+    /// So provide here some tool functions to access these elements
+    /// Note that these functions are relatively expensive in execution time.
+    /// So only use them once at object creation time and store direct references to the values
+
+    class PathElement {
+    public:
+        PathElement(unsigned index) : _data(new IndexData(index)) {}
+        PathElement(const std::string& name) : _data(new FieldData(name)) {}
+
+        bool isFieldValue() const
+        { return _data->toFieldData(); }
+        bool isIndexValue() const
+        { return _data->toIndexData(); }
+
+        unsigned getIndexValue() const
+        {
+            const IndexData* indexData = _data->toIndexData();
+            if (!indexData)
+                return ~unsigned(0);
+            return indexData->_index;
+        }
+
+        std::string getFieldValue() const
+        {
+            const FieldData* fieldData = _data->toFieldData();
+            if (!fieldData)
+                return std::string();
+            return fieldData->_name;
+        }
+
+        // Want to be able to use that in std::map and std::set
+        bool operator<(const PathElement& pathElement) const
+        { return _data->less(pathElement._data.get()); }
+        bool operator==(const PathElement& pathElement) const
+        { return _data->equal(pathElement._data.get()); }
+
+        void append(std::string& s) const
+        { _data->append(s); }
+
+    private:
+        struct FieldData;
+        struct IndexData;
+        struct Data : public SGReferenced {
+            virtual ~Data();
+            virtual const FieldData* toFieldData() const;
+            virtual const IndexData* toIndexData() const;
+            virtual bool less(const Data*) const = 0;
+            virtual bool equal(const Data*) const = 0;
+            virtual void append(std::string&) const = 0;
+        };
+        struct FieldData : public Data {
+            FieldData(const std::string& name);
+            virtual ~FieldData();
+            virtual const FieldData* toFieldData() const;
+            virtual bool less(const Data* data) const;
+            virtual bool equal(const Data* data) const;
+            virtual void append(std::string& s) const;
+            std::string _name;
+        };
+        struct IndexData : public Data {
+            IndexData(unsigned index);
+            virtual ~IndexData();
+            virtual const IndexData* toIndexData() const;
+            virtual bool less(const Data* data) const;
+            virtual bool equal(const Data* data) const;
+            virtual void append(std::string& s) const;
+            unsigned _index;
+        };
+
+        SGSharedPtr<Data> _data;
+    };
+    typedef std::list<PathElement> Path;
+    typedef std::pair<std::string, Path> AttributePathPair;
+    typedef std::pair<unsigned, Path> IndexPathPair;
+
+    static std::string toString(const Path& path);
+    static std::string toString(const AttributePathPair& path)
+    { return path.first + toString(path.second); }
+    static AttributePathPair toAttributePathPair(const std::string& s);
+    static Path toPath(const std::string& s)
+    { return toAttributePathPair(s).second; }
+
+private:
+    // SGSharedPtr<const TimeStamp> _timeStamp;
+};
+
+class HLADataElementProvider {
+public:
+    class AbstractProvider : public SGReferenced {
+    public:
+        virtual ~AbstractProvider() { }
+        virtual HLADataElement* getDataElement(const HLADataElement::Path& path) = 0;
+        // virtual HLADataElement* getDataElement(const HLADataElement::Path& path, const HLADataType* dataType)
+        // {
+        //     SGSharedPtr<HLADataElement> dataElement = getDataElement(path);
+        //     if (!dataElement.valid())
+        //         return 0;
+        //     if (!dataElement->setDataType(dataType))
+        //         return 0;
+        //     return dataElement.release();
+        // }
+    };
+
+    HLADataElementProvider()
+    { }
+    HLADataElementProvider(HLADataElement* dataElement) :
+        _provider(new ConcreteProvider(dataElement))
+    { }
+    HLADataElementProvider(const SGSharedPtr<HLADataElement>& dataElement) :
+        _provider(new ConcreteProvider(dataElement))
+    { }
+    HLADataElementProvider(AbstractProvider* provider) :
+        _provider(provider)
+    { }
+
+    HLADataElement* getDataElement(const HLADataElement::Path& path) const
+    {
+        if (!_provider.valid())
+            return 0;
+        return _provider->getDataElement(path);
+    }
+
+private:
+    class ConcreteProvider : public AbstractProvider {
+    public:
+        ConcreteProvider(const SGSharedPtr<HLADataElement>& dataElement) :
+            _dataElement(dataElement)
+        { }
+        virtual HLADataElement* getDataElement(const HLADataElement::Path&)
+        { return _dataElement.get(); }
+    private:
+        SGSharedPtr<HLADataElement> _dataElement;
+    };
+
+    SGSharedPtr<AbstractProvider> _provider;
+};
+
+typedef std::map<HLADataElement::Path, HLADataElementProvider> HLAPathElementMap;
+typedef std::map<unsigned, HLAPathElementMap> HLAAttributePathElementMap;
+
+}
+
+#endif

simgear/hla/HLADataElementVisitor.hxx

@@ -0,0 +1,57 @@
+// Copyright (C) 2009 - 2011  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 HLADataElementVisitor_hxx
+#define HLADataElementVisitor_hxx
+
+namespace simgear {
+
+class HLABasicDataElement;
+class HLAAbstractEnumeratedDataElement;
+class HLAAbstractFixedRecordDataElement;
+class HLAAbstractArrayDataElement;
+class HLAAbstractVariantDataElement;
+
+class HLADataElementVisitor {
+public:
+    virtual ~HLADataElementVisitor() {}
+
+    virtual void apply(HLADataElement&);
+
+    virtual void apply(HLABasicDataElement&);
+    virtual void apply(HLAAbstractEnumeratedDataElement&);
+    virtual void apply(HLAAbstractArrayDataElement&);
+    virtual void apply(HLAAbstractFixedRecordDataElement&);
+    virtual void apply(HLAAbstractVariantDataElement&);
+};
+
+class HLAConstDataElementVisitor {
+public:
+    virtual ~HLAConstDataElementVisitor() {}
+
+    virtual void apply(const HLADataElement&);
+
+    virtual void apply(const HLABasicDataElement&);
+    virtual void apply(const HLAAbstractEnumeratedDataElement&);
+    virtual void apply(const HLAAbstractArrayDataElement&);
+    virtual void apply(const HLAAbstractFixedRecordDataElement&);
+    virtual void apply(const HLAAbstractVariantDataElement&);
+};
+
+}
+
+#endif

simgear/hla/HLADataType.cxx

@@ -0,0 +1,104 @@
+// Copyright (C) 2009 - 2010  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 "HLADataType.hxx"
+
+#include "HLADataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLADataType::HLADataType(const std::string& name, unsigned alignment) :
+    _name(name),
+    _alignment(1)
+{
+    setAlignment(alignment);
+}
+
+HLADataType::~HLADataType()
+{
+}
+
+void
+HLADataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLADataTypeReference*
+HLADataType::toDataTypeReference() const
+{
+    return 0;
+}
+
+const HLABasicDataType*
+HLADataType::toBasicDataType() const
+{
+    return 0;
+}
+
+const HLAArrayDataType*
+HLADataType::toArrayDataType() const
+{
+    return 0;
+}
+
+const HLAEnumeratedDataType*
+HLADataType::toEnumeratedDataType() const
+{
+    return 0;
+}
+
+const HLAFixedRecordDataType*
+HLADataType::toFixedRecordDataType() const
+{
+    return 0;
+}
+
+const HLAVariantDataType*
+HLADataType::toVariantDataType() const
+{
+    return 0;
+}
+
+void
+HLADataType::setAlignment(unsigned alignment)
+{
+    /// FIXME: more checks
+    if (alignment == 0)
+        _alignment = 1;
+    else
+        _alignment = alignment;
+}
+
+HLADataTypeReference::~HLADataTypeReference()
+{
+}
+
+void
+HLADataTypeReference::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLADataTypeReference*
+HLADataTypeReference::toDataTypeReference() const
+{
+    return this;
+}
+
+}

simgear/hla/HLADataType.hxx

@@ -0,0 +1,99 @@
+// Copyright (C) 2009 - 2010  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 HLADataType_hxx
+#define HLADataType_hxx
+
+#include <string>
+#include <simgear/structure/SGWeakPtr.hxx>
+#include <simgear/structure/SGWeakReferenced.hxx>
+#include "RTIData.hxx"
+
+namespace simgear {
+
+class HLADataTypeVisitor;
+
+class HLADataTypeReference;
+class HLABasicDataType;
+class HLAArrayDataType;
+class HLAEnumeratedDataType;
+class HLAFixedRecordDataType;
+class HLAVariantDataType;
+
+enum HLAUpdateType {
+    HLAStaticUpdate,
+    HLAPeriodicUpdate,
+    HLAConditionalUpdate,
+    HLAUndefinedUpdate
+};
+
+class HLADataType : public SGWeakReferenced {
+public:
+    virtual ~HLADataType();
+
+    const std::string& getName() const
+    { return _name; }
+
+    const std::string& getSemantics() const
+    { return _semantics; }
+    void setSemantics(const std::string& semantics)
+    { _semantics = semantics; }
+
+    unsigned getAlignment() const
+    { return _alignment; }
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLADataTypeReference* toDataTypeReference() const;
+    virtual const HLABasicDataType* toBasicDataType() const;
+    virtual const HLAArrayDataType* toArrayDataType() const;
+    virtual const HLAEnumeratedDataType* toEnumeratedDataType() const;
+    virtual const HLAFixedRecordDataType* toFixedRecordDataType() const;
+    virtual const HLAVariantDataType* toVariantDataType() const;
+
+protected:
+    HLADataType(const std::string& name, unsigned alignment = 1);
+    void setAlignment(unsigned alignment);
+
+private:
+    std::string _name;
+    std::string _semantics;
+    unsigned _alignment;
+};
+
+// Weak reference to a data type. Used to implement self referencing data types
+class HLADataTypeReference : public HLADataType {
+public:
+    HLADataTypeReference(const SGSharedPtr<HLADataType>& dataType) :
+        HLADataType(dataType->getName(), dataType->getAlignment()),
+        _dataType(dataType)
+    { }
+    virtual ~HLADataTypeReference();
+
+    SGSharedPtr<const HLADataType> getDataType() const
+    { return _dataType.lock(); }
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+    virtual const HLADataTypeReference* toDataTypeReference() const;
+
+private:
+    SGWeakPtr<const HLADataType> _dataType;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLADataTypeVisitor.cxx

@@ -0,0 +1,188 @@
+// Copyright (C) 2009 - 2010  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 "HLADataTypeVisitor.hxx"
+
+#include "HLAArrayDataElement.hxx"
+#include "HLABasicDataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+#include "HLAEnumeratedDataElement.hxx"
+#include "HLAFixedRecordDataElement.hxx"
+#include "HLAVariantDataElement.hxx"
+
+namespace simgear {
+
+HLADataElementFactoryVisitor::~HLADataElementFactoryVisitor()
+{
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLADataType& dataType)
+{
+    SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Can not find a suitable data element for data type \""
+           << dataType.getName() << "\"");
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt8DataType& dataType)
+{
+    _dataElement = new HLASCharDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt8DataType& dataType)
+{
+    _dataElement = new HLAUCharDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt16DataType& dataType)
+{
+    _dataElement = new HLAShortDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt16DataType& dataType)
+{
+    _dataElement = new HLAUShortDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt32DataType& dataType)
+{
+    _dataElement = new HLAIntDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt32DataType& dataType)
+{
+    _dataElement = new HLAUIntDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt64DataType& dataType)
+{
+    _dataElement = new HLALongDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt64DataType& dataType)
+{
+    _dataElement = new HLAULongDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFloat32DataType& dataType)
+{
+    _dataElement = new HLAFloatDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFloat64DataType& dataType)
+{
+    _dataElement = new HLADoubleDataElement(&dataType);
+}
+
+class HLADataElementFactoryVisitor::ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
+public:
+    virtual HLADataElement* createElement(const HLAArrayDataElement& element, unsigned index)
+    {
+        const HLADataType* dataType = element.getElementDataType();
+        if (!dataType)
+            return 0;
+        
+        HLADataElementFactoryVisitor visitor;
+        dataType->accept(visitor);
+        return visitor.getDataElement();
+    }
+};
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFixedArrayDataType& dataType)
+{
+    if (dataType.getIsString()) {
+        _dataElement = new HLAStringDataElement(&dataType);
+    } else {
+        SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+        arrayDataElement = new HLAArrayDataElement(&dataType);
+        arrayDataElement->setDataElementFactory(new ArrayDataElementFactory);
+        arrayDataElement->setNumElements(dataType.getNumElements());
+        _dataElement = arrayDataElement;
+    }
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    if (dataType.getIsString()) {
+        _dataElement = new HLAStringDataElement(&dataType);
+    } else {
+        SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+        arrayDataElement = new HLAArrayDataElement(&dataType);
+        arrayDataElement->setDataElementFactory(new ArrayDataElementFactory);
+        _dataElement = arrayDataElement;
+    }
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAEnumeratedDataType& dataType)
+{
+    _dataElement = new HLAEnumeratedDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFixedRecordDataType& dataType)
+{
+    SGSharedPtr<HLAFixedRecordDataElement> recordDataElement;
+    recordDataElement = new HLAFixedRecordDataElement(&dataType);
+
+    unsigned numFields = dataType.getNumFields();
+    for (unsigned i = 0; i < numFields; ++i) {
+        HLADataElementFactoryVisitor visitor;
+        dataType.getFieldDataType(i)->accept(visitor);
+        recordDataElement->setField(i, visitor._dataElement.get());
+    }
+
+    _dataElement = recordDataElement;
+}
+
+class HLADataElementFactoryVisitor::VariantDataElementFactory : public HLAVariantDataElement::DataElementFactory {
+public:
+    virtual HLADataElement* createElement(const HLAVariantDataElement& element, unsigned index)
+    {
+        const HLAVariantDataType* dataType = element.getDataType();
+        if (!dataType)
+            return 0;
+        const HLADataType* alternativeDataType = element.getAlternativeDataType();
+        if (!alternativeDataType)
+            return 0;
+        HLADataElementFactoryVisitor visitor;
+        alternativeDataType->accept(visitor);
+        return visitor.getDataElement();
+    }
+};
+
+void
+HLADataElementFactoryVisitor::apply(const HLAVariantDataType& dataType)
+{
+    SGSharedPtr<HLAVariantDataElement> variantDataElement;
+    variantDataElement = new HLAVariantDataElement(&dataType);
+    variantDataElement->setDataElementFactory(new VariantDataElementFactory);
+    _dataElement = variantDataElement;
+}
+
+} // namespace simgear

simgear/hla/HLADataTypeVisitor.hxx

@@ -0,0 +1,671 @@
+// Copyright (C) 2009 - 2010  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 HLADataTypeVisitor_hxx
+#define HLADataTypeVisitor_hxx
+
+#include <cassert>
+#include <string>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/math/SGMath.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLABasicDataType.hxx"
+#include "HLADataElement.hxx"
+#include "HLAEnumeratedDataType.hxx"
+#include "HLAFixedRecordDataType.hxx"
+#include "HLAVariantDataType.hxx"
+
+namespace simgear {
+
+class HLADataTypeVisitor {
+public:
+    virtual ~HLADataTypeVisitor() {}
+
+    virtual void apply(const HLADataType& dataType)
+    { }
+
+    virtual void apply(const HLADataTypeReference& dataType)
+    {
+        SGSharedPtr<const HLADataType> dataTypeReference = dataType.getDataType();
+        if (!dataTypeReference.valid()) {
+            SG_LOG(SG_NETWORK, SG_WARN, "HLADataTypeReference weak reference vanished!");
+            return;
+        }
+        dataTypeReference->accept(*this);
+    }
+
+    virtual void apply(const HLABasicDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+    virtual void apply(const HLAInt8DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt16DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+
+    virtual void apply(const HLAArrayDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    { apply(static_cast<const HLAArrayDataType&>(dataType)); }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    { apply(static_cast<const HLAArrayDataType&>(dataType)); }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+};
+
+/// Walks the datatype tree and checks if it is completely defined
+class HLADataTypeCheckVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeCheckVisitor() : _valid(true) {}
+
+    bool valid() const { return _valid; }
+
+    virtual void apply(const HLAInt8DataType& dataType) { }
+    virtual void apply(const HLAUInt8DataType& dataType) { }
+    virtual void apply(const HLAInt16DataType& dataType) { }
+    virtual void apply(const HLAUInt16DataType& dataType) { }
+    virtual void apply(const HLAInt32DataType& dataType) { }
+    virtual void apply(const HLAUInt32DataType& dataType) { }
+    virtual void apply(const HLAInt64DataType& dataType) { }
+    virtual void apply(const HLAUInt64DataType& dataType) { }
+    virtual void apply(const HLAFloat32DataType& dataType) { }
+    virtual void apply(const HLAFloat64DataType& dataType) { }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        if (!dataType.getElementDataType())
+            _valid = false;
+        else
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        if (!dataType.getElementDataType())
+            _valid = false;
+        else
+            dataType.getElementDataType()->accept(*this);
+
+        if (!dataType.getSizeDataType())
+            _valid = false;
+        else
+            dataType.getSizeDataType()->accept(*this);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        if (!dataType.getRepresentation())
+            _valid = false;
+        else
+            dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i) {
+            if (!dataType.getFieldDataType(i))
+                _valid = false;
+            else
+                dataType.getFieldDataType(i)->accept(*this);
+        }
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    { assert(0); }
+
+protected:
+    bool _valid;
+};
+
+class HLADataTypeDecodeVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeDecodeVisitor(HLADecodeStream& stream) : _stream(stream) {}
+    virtual ~HLADataTypeDecodeVisitor() {}
+
+    virtual void apply(const HLAInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat64DataType& dataType) { dataType.skip(_stream); }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        unsigned numElements = dataType.getNumElements();
+        for (unsigned i = 0; i < numElements; ++i)
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i)
+            dataType.getFieldDataType(i)->accept(*this);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+
+protected:
+    HLADecodeStream& _stream;
+};
+
+class HLADataTypeEncodeVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeEncodeVisitor(HLAEncodeStream& stream) : _stream(stream) {}
+    virtual ~HLADataTypeEncodeVisitor() {}
+
+    virtual void apply(const HLAInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat64DataType& dataType) { dataType.skip(_stream); }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        /// FIXME, might vanish in this sense ...
+        // dataType.encode(_stream, *this);
+        unsigned numElements = dataType.getNumElements();
+        for (unsigned i = 0; i < numElements; ++i)
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i)
+            dataType.getFieldDataType(i)->accept(*this);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+
+protected:
+    HLAEncodeStream& _stream;
+};
+
+/// Begin implementation of some get/set visitors
+
+class HLAScalarDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    HLAScalarDecodeVisitor(HLADecodeStream& stream) :
+        HLADataTypeDecodeVisitor(stream)
+    {}
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+};
+
+class HLAScalarEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    HLAScalarEncodeVisitor(HLAEncodeStream& stream) :
+        HLADataTypeEncodeVisitor(stream)
+    {}
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+};
+
+class HLAFixedRecordDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    HLAFixedRecordDecodeVisitor(HLADecodeStream& stream) :
+        HLADataTypeDecodeVisitor(stream)
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+};
+
+class HLAFixedRecordEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    HLAFixedRecordEncodeVisitor(HLAEncodeStream& stream) :
+        HLADataTypeEncodeVisitor(stream)
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+};
+
+template<typename T>
+class HLATemplateDecodeVisitor : public HLAScalarDecodeVisitor {
+public:
+    typedef T value_type;
+
+    HLATemplateDecodeVisitor(HLADecodeStream& stream, const value_type& value = value_type()) :
+        HLAScalarDecodeVisitor(stream),
+        _value(value)
+    {}
+
+    void setValue(const value_type& value)
+    { _value = value; }
+    const value_type& getValue() const
+    { return _value; }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        int8_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        uint8_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        int16_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        uint16_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        int32_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        uint32_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        int64_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        uint64_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        float value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        double value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+
+private:
+    value_type _value;
+};
+
+template<typename T>
+class HLATemplateEncodeVisitor : public HLAScalarEncodeVisitor {
+public:
+    typedef T value_type;
+
+    HLATemplateEncodeVisitor(HLAEncodeStream& stream, const value_type& value = value_type()) :
+        HLAScalarEncodeVisitor(stream),
+        _value(value)
+    {}
+
+    void setValue(const value_type& value)
+    { _value = value; }
+    const value_type& getValue() const
+    { return _value; }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+
+private:
+    value_type _value;
+};
+
+inline void HLADataTypeDecodeVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    HLATemplateDecodeVisitor<unsigned> numElementsVisitor(_stream);
+    dataType.getSizeDataType()->accept(numElementsVisitor);
+    unsigned numElements = numElementsVisitor.getValue();
+    for (unsigned i = 0; i < numElements; ++i)
+        dataType.getElementDataType()->accept(*this);
+}
+
+inline void HLADataTypeEncodeVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    HLATemplateEncodeVisitor<unsigned> numElementsVisitor(_stream, 0);
+    dataType.getSizeDataType()->accept(numElementsVisitor);
+}
+
+/// Generate standard data elements according to the traversed type
+class HLADataElementFactoryVisitor : public HLADataTypeVisitor {
+public:
+    virtual ~HLADataElementFactoryVisitor();
+
+    virtual void apply(const HLADataType& dataType);
+
+    virtual void apply(const HLAInt8DataType& dataType);
+    virtual void apply(const HLAUInt8DataType& dataType);
+    virtual void apply(const HLAInt16DataType& dataType);
+    virtual void apply(const HLAUInt16DataType& dataType);
+    virtual void apply(const HLAInt32DataType& dataType);
+    virtual void apply(const HLAUInt32DataType& dataType);
+    virtual void apply(const HLAInt64DataType& dataType);
+    virtual void apply(const HLAUInt64DataType& dataType);
+    virtual void apply(const HLAFloat32DataType& dataType);
+    virtual void apply(const HLAFloat64DataType& dataType);
+
+    virtual void apply(const HLAFixedArrayDataType& dataType);
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType);
+
+    virtual void apply(const HLAFixedRecordDataType& dataType);
+
+    virtual void apply(const HLAVariantDataType& dataType);
+
+    HLADataElement* getDataElement()
+    { return _dataElement.release(); }
+
+protected:
+    class ArrayDataElementFactory;
+    class VariantDataElementFactory;
+
+    SGSharedPtr<HLADataElement> _dataElement;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAEnumeratedDataElement.cxx

@@ -0,0 +1,142 @@
+// Copyright (C) 2009 - 2010  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 "HLAEnumeratedDataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLAAbstractEnumeratedDataElement::HLAAbstractEnumeratedDataElement(const HLAEnumeratedDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAAbstractEnumeratedDataElement::~HLAAbstractEnumeratedDataElement()
+{
+}
+
+void
+HLAAbstractEnumeratedDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLAAbstractEnumeratedDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAAbstractEnumeratedDataElement::decode(HLADecodeStream& stream)
+{
+    if (!_dataType.valid())
+        return false;
+    unsigned index;
+    if (!_dataType->decode(stream, index))
+        return false;
+    setEnumeratorIndex(index);
+    return true;
+}
+
+bool
+HLAAbstractEnumeratedDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->encode(stream, getEnumeratorIndex());
+}
+
+const HLAEnumeratedDataType*
+HLAAbstractEnumeratedDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAAbstractEnumeratedDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAEnumeratedDataType* enumeratedDataType = dataType->toEnumeratedDataType();
+    if (!enumeratedDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAEnumeratedDataType: unable to set data type!");
+        return false;
+    }
+    setDataType(enumeratedDataType);
+    return true;
+}
+
+void
+HLAAbstractEnumeratedDataElement::setDataType(const HLAEnumeratedDataType* dataType)
+{
+    _dataType = dataType;
+}
+
+const HLABasicDataType*
+HLAAbstractEnumeratedDataElement::getRepresentationDataType() const
+{
+    if (!_dataType.valid())
+        return 0;
+    return _dataType->getRepresentation();
+}
+
+std::string
+HLAAbstractEnumeratedDataElement::getStringRepresentation() const
+{
+    if (!_dataType.valid())
+        return std::string();
+    return _dataType->getString(getEnumeratorIndex());
+}
+
+bool
+HLAAbstractEnumeratedDataElement::setStringRepresentation(const std::string& name)
+{
+    if (!_dataType.valid())
+        return false;
+    unsigned index = _dataType->getIndex(name);
+    if (_dataType->getNumEnumerators() <= index)
+        return false;
+    setEnumeratorIndex(index);
+    return true;
+}
+
+
+HLAEnumeratedDataElement::HLAEnumeratedDataElement(const HLAEnumeratedDataType* dataType) :
+    HLAAbstractEnumeratedDataElement(dataType),
+    _enumeratorIndex(~unsigned(0))
+{
+}
+
+HLAEnumeratedDataElement::~HLAEnumeratedDataElement()
+{
+}
+
+unsigned
+HLAEnumeratedDataElement::getEnumeratorIndex() const
+{
+    return _enumeratorIndex;
+}
+
+void
+HLAEnumeratedDataElement::setEnumeratorIndex(unsigned index)
+{
+    _enumeratorIndex = index;
+}
+
+}

simgear/hla/HLAEnumeratedDataElement.hxx

@@ -0,0 +1,67 @@
+// Copyright (C) 2009 - 2010  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 HLAEnumeratedDataElement_hxx
+#define HLAEnumeratedDataElement_hxx
+
+#include "HLADataElement.hxx"
+#include "HLAEnumeratedDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractEnumeratedDataElement : public HLADataElement {
+public:
+    HLAAbstractEnumeratedDataElement(const HLAEnumeratedDataType* dataType);
+    virtual ~HLAAbstractEnumeratedDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAEnumeratedDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLAEnumeratedDataType* dataType);
+
+    const HLABasicDataType* getRepresentationDataType() const;
+
+    std::string getStringRepresentation() const;
+    bool setStringRepresentation(const std::string& name);
+
+    virtual unsigned getEnumeratorIndex() const = 0;
+    virtual void setEnumeratorIndex(unsigned index) = 0;
+
+private:
+    SGSharedPtr<const HLAEnumeratedDataType> _dataType;
+};
+
+class HLAEnumeratedDataElement : public HLAAbstractEnumeratedDataElement {
+public:
+    HLAEnumeratedDataElement(const HLAEnumeratedDataType* dataType);
+    virtual ~HLAEnumeratedDataElement();
+
+    virtual unsigned getEnumeratorIndex() const;
+    virtual void setEnumeratorIndex(unsigned index);
+
+private:
+    unsigned _enumeratorIndex;
+};
+
+}
+
+#endif

simgear/hla/HLAEnumeratedDataType.cxx

@@ -0,0 +1,180 @@
+// Copyright (C) 2009 - 2010  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 "HLAEnumeratedDataType.hxx"
+
+#include <map>
+#include <sstream>
+#include <vector>
+#include "HLAEnumeratedDataType.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+template<typename DataType, typename T>
+class HLAEnumeratedDataType::Map : public HLAEnumeratedDataType::AbstractMap {
+public:
+    typedef typename std::pair<std::string,T> RepresentationPair;
+    typedef typename std::map<T, unsigned> RepresentationIndexMap;
+    typedef typename std::vector<RepresentationPair> IndexRepresentationMap;
+    typedef typename std::map<std::string, unsigned> StringIndexMap;
+
+    Map(const DataType* dataType) :
+        _dataType(dataType)
+    { }
+    virtual bool encode(HLAEncodeStream& stream, unsigned index) const
+    {
+        T value = _otherRepresentation;
+        if (index < _indexRepresentationMap.size())
+            value = _indexRepresentationMap[index].second;
+        if (!_dataType->encode(stream, value))
+            return false;
+        return true;
+    }
+    virtual bool decode(HLADecodeStream& stream, unsigned& index) const
+    {
+        T value;
+        if (!_dataType->decode(stream, value))
+            return false;
+        typename RepresentationIndexMap::const_iterator i;
+        i = _representationIndexMap.find(value);
+        if (i == _representationIndexMap.end())
+            index = _indexRepresentationMap.size();
+        else
+            index = i->second;
+        return true;
+    }
+    virtual const HLABasicDataType* getDataType() const
+    { return _dataType.get(); }
+
+    virtual bool add(const std::string& name, const std::string& number)
+    {
+        std::stringstream ss(number);
+        T value;
+        ss >> value;
+        if (ss.fail())
+            return false;
+        if (_representationIndexMap.find(value) != _representationIndexMap.end())
+            return false;
+        if (_stringIndexMap.find(name) != _stringIndexMap.end())
+            return false;
+        _stringIndexMap[name] = _indexRepresentationMap.size();
+        _representationIndexMap[value] = _indexRepresentationMap.size();
+        _indexRepresentationMap.push_back(RepresentationPair(name, value));
+        return true;
+    }
+    virtual std::string getString(unsigned index) const
+    {
+        if (_indexRepresentationMap.size() <= index)
+            return std::string();
+        return _indexRepresentationMap[index].first;
+    }
+    virtual unsigned getIndex(const std::string& name) const
+    {
+        typename StringIndexMap::const_iterator i = _stringIndexMap.find(name);
+        if (i == _stringIndexMap.end())
+            return ~unsigned(0);
+        return i->second;
+    }
+    virtual unsigned getNumEnumerators() const
+    { return _indexRepresentationMap.size(); }
+
+private:
+    IndexRepresentationMap _indexRepresentationMap;
+    StringIndexMap _stringIndexMap;
+    RepresentationIndexMap _representationIndexMap;
+
+    T _otherRepresentation;
+    SGSharedPtr<const DataType> _dataType;
+};
+
+class HLAEnumeratedDataType::RepresentationVisitor : public HLADataTypeVisitor {
+public:
+    virtual void apply(const HLAInt8DataType& dataType)
+    { _map = new Map<HLAInt8DataType, int8_t>(&dataType); }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    { _map = new Map<HLAUInt8DataType, uint8_t>(&dataType); }
+    virtual void apply(const HLAInt16DataType& dataType)
+    { _map = new Map<HLAInt16DataType, int16_t>(&dataType); }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    { _map = new Map<HLAUInt16DataType, uint16_t>(&dataType); }
+    virtual void apply(const HLAInt32DataType& dataType)
+    { _map = new Map<HLAInt32DataType, int32_t>(&dataType); }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    { _map = new Map<HLAUInt32DataType, uint32_t>(&dataType); }
+    virtual void apply(const HLAInt64DataType& dataType)
+    { _map = new Map<HLAInt64DataType, int64_t>(&dataType); }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    { _map = new Map<HLAUInt64DataType, uint64_t>(&dataType); }
+
+    SGSharedPtr<AbstractMap> _map;
+};
+
+HLAEnumeratedDataType::HLAEnumeratedDataType(const std::string& name) :
+    HLADataType(name)
+{
+}
+
+HLAEnumeratedDataType::~HLAEnumeratedDataType()
+{
+}
+
+void
+HLAEnumeratedDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLAEnumeratedDataType*
+HLAEnumeratedDataType::toEnumeratedDataType() const
+{
+    return this;
+}
+
+bool
+HLAEnumeratedDataType::decode(HLADecodeStream& stream, unsigned& index) const
+{
+    if (!_map.valid())
+        return false;
+
+    if (!_map->decode(stream, index))
+        return false;
+    return true;
+}
+
+bool
+HLAEnumeratedDataType::encode(HLAEncodeStream& stream, unsigned index) const
+{
+    if (!_map.valid())
+        return false;
+
+    return _map->encode(stream, index);
+}
+
+void
+HLAEnumeratedDataType::setRepresentation(HLABasicDataType* representation)
+{
+    if (!representation)
+        return;
+
+    RepresentationVisitor representationVisitor;
+    representation->accept(representationVisitor);
+    _map.swap(representationVisitor._map);
+}
+
+} // namespace simgear
+