Merge branch 'next' of D:\Git_New\flightgear into next

src/ATC/atcutils.hxx

@@ -52,7 +52,8 @@
 #if !ENABLE_ATCDCL
 
 class SGPath;
-class ATCData;
+
+
 
 // Possible types of ATC type that the radios may be tuned to.
 // INVALID implies not tuned in to anything.
@@ -67,6 +68,18 @@ enum atc_type {
   INVALID	 /* must be last element;  see ATC_NUM_TYPES */
 };
 
+struct ATCData {
+        ATCData() : type(INVALID), cart(0, 0, 0), freq(0), range(0) {}
+	atc_type type;
+	SGGeod geod;
+	SGVec3d cart;
+	unsigned short int freq;
+	unsigned short int range;
+	std::string ident;
+	std::string name;
+};
+
+
 
 // A list of ATC stations
 typedef std::list < ATCData > comm_list_type;

src/Autopilot/autopilotgroup.cxx

@@ -194,8 +194,7 @@ void FGXMLAutopilotGroup::init()
             continue;
         }
 
-        SGPath config( globals->get_fg_root() );
+        SGPath config = globals->resolve_aircraft_path(pathNode->getStringValue());
-        config.append( pathNode->getStringValue() );
 
         SG_LOG( SG_ALL, SG_INFO, "Reading autopilot configuration from " << config.str() );
 

src/Cockpit/panel.cxx

@@ -122,11 +122,7 @@ FGTextureManager::createTexture (const string &relativePath, bool staticTexture)
 {
   osg::Texture2D* texture = _textureMap[relativePath].get();
   if (texture == 0) {
-    SG_LOG( SG_COCKPIT, SG_DEBUG,
+    SGPath tpath = globals->resolve_aircraft_path(relativePath);
-            "Texture " << relativePath << " does not yet exist" );
-    SGPath tpath(globals->get_fg_root());
-    tpath.append(relativePath);
-
     texture = SGLoadTexture2D(staticTexture, tpath);
 
     _textureMap[relativePath] = texture;

src/Cockpit/panel_io.cxx

@@ -839,10 +839,9 @@ fgReadPanel (istream &input)
 FGPanel *
 fgReadPanel (const string &relative_path)
 {
-  SGPath path(globals->get_fg_root());
+  SGPath path = globals->resolve_aircraft_path(relative_path);
-  path.append(relative_path);
   SGPropertyNode root;
-
+  
   try {
     readProperties(path.str(), &root);
   } catch (const sg_exception &e) {

src/GUI/gui.h

@@ -60,9 +60,7 @@ extern void fgDumpSnapShotWrapper();
 extern void fgHiResDumpWrapper();
 extern void fgHiResDump();
 #endif
-#if defined( _WIN32 ) && !defined(__MINGW32__)
+
-extern void printScreen();
-#endif
 extern void helpCb();
 
 typedef struct {

src/GUI/gui_funcs.cxx

@@ -53,11 +53,8 @@
 
 #ifdef _WIN32
 #  include <shellapi.h>
-# if !defined(__MINGW32__)
-#  include <simgear/screen/win32-printer.h>
-#  include <simgear/screen/GlBitmaps.h>
-# endif
 #endif
+
 #include "gui.h"
 
 using std::string;
@@ -75,9 +72,6 @@ const __fg_gui_fn_t __fg_gui_fn[] = {
         {"dumpHiResSnapShot", fgHiResDumpWrapper},
 #endif
         {"dumpSnapShot", fgDumpSnapShotWrapper},
-#if defined( _WIN32 ) && !defined(__MINGW32__)
-        {"printScreen", printScreen},
-#endif
         // Help
         {"helpCb", helpCb},
 
@@ -403,61 +397,6 @@ void fgHiResDump()
 }
 #endif // #if defined( TR_HIRES_SNAP)
 
-
-#if defined( _WIN32 ) && !defined(__MINGW32__)
-
-void rotateView( double roll, double pitch, double yaw )
-{
-	// rotate view
-}
-
-GlBitmap *b1 = NULL;
-GLubyte *hiResScreenCapture( int multiplier )
-{
-    float oldfov = fgGetDouble("/sim/current-view/field-of-view");
-    float fov = oldfov / multiplier;
-    FGViewer *v = globals->get_current_view();
-    fgSetDouble("/sim/current-view/field-of-view", fov);
-//     globals->get_renderer()->init();
-    int cur_width = fgGetInt("/sim/startup/xsize");
-    int cur_height = fgGetInt("/sim/startup/ysize");
-    delete( b1 );
-    // New empty (mostly) bitmap
-    b1 = new GlBitmap( GL_RGB, 1, 1, (unsigned char *)"123" );
-    int x,y;
-    for ( y = 0; y < multiplier; y++ ) {
-	for ( x = 0; x < multiplier; x++ ) {
-	    globals->get_renderer()->resize( cur_width, cur_height );
-	    // pan to tile
-	    rotateView( 0, (y*fov)-((multiplier-1)*fov/2), (x*fov)-((multiplier-1)*fov/2) );
-	    globals->get_renderer()->update( false );
-	    // restore view
-	    GlBitmap b2;
-	    b1->copyBitmap( &b2, cur_width*x, cur_height*y );
-	}
-    }
-    fgSetDouble("/sim/current-view/field-of-view", oldfov);
-    return b1->getBitmap();
-}
-#endif
-
-#if defined( _WIN32 ) && !defined(__MINGW32__)
-// win32 print screen function
-void printScreen () {
-    int mouse = fgGetMouseCursor();
-    fgSetMouseCursor(MOUSE_CURSOR_NONE);
-
-    CGlPrinter p( CGlPrinter::PRINT_BITMAP );
-    int cur_width = fgGetInt("/sim/startup/xsize");
-    int cur_height = fgGetInt("/sim/startup/ysize");
-    p.Begin( "FlightGear", cur_width*3, cur_height*3 );
-    p.End( hiResScreenCapture(3) );
-
-    fgSetMouseCursor(mouse);
-}
-#endif // #ifdef _WIN32
-
-
 void fgDumpSnapShotWrapper () {
     fgDumpSnapShot();
 }

src/GUI/menubar.cxx

@@ -36,16 +36,6 @@ do_hires_snapshot_dialog (const SGPropertyNode * arg)
 }
 #endif // TR_HIRES_SNAP
 
-#if defined( _WIN32 ) && !defined(__MINGW32__)
-extern void printScreen ();
-static bool
-do_print_dialog (const SGPropertyNode * arg)
-{
-    printScreen();
-    return true;
-}
-#endif
-
 extern void helpCb ();
 static bool
 do_help_dialog (const SGPropertyNode * arg)
@@ -60,9 +50,6 @@ static struct {
 } deprecated_dialogs [] = {
 #if defined(TR_HIRES_SNAP)
     { "old-hires-snapshot-dialog", do_hires_snapshot_dialog },
-#endif
-#if defined( _WIN32 ) && !defined(__MINGW32__)
-    { "old-print-dialog", do_print_dialog },
 #endif
     { "old-help-dialog", do_help_dialog },
     { 0, 0 }

src/Instrumentation/KLN89/kln89_page_apt.cxx

@@ -26,7 +26,11 @@
 #endif
 
 #include "kln89_page_apt.hxx"
-#include <ATCDCL/commlist.hxx>
+#if ENABLE_ATCDCL
+#    include <ATCDCL/commlist.hxx>
+#else
+  #include <ATC/atcutils.hxx>
+#endif
 #include <Main/globals.hxx>
 #include <Airports/runways.hxx>
 #include <Airports/simple.hxx>

src/Instrumentation/instrument_mgr.cxx

@@ -62,9 +62,8 @@ FGInstrumentMgr::FGInstrumentMgr () :
     SGPropertyNode *path_n = fgGetNode("/sim/instrumentation/path");
 
     if (path_n) {
-        SGPath config( globals->get_fg_root() );
+        SGPath config = globals->resolve_aircraft_path(path_n->getStringValue());
-        config.append( path_n->getStringValue() );
+        
-
         SG_LOG( SG_ALL, SG_INFO, "Reading instruments from "
                 << config.str() );
         try {

src/Instrumentation/mk_viii.cxx

@@ -182,6 +182,8 @@ MK_VIII::PropertiesHandler::init ()
   mk_node(altimeter_serviceable) = fgGetNode("/instrumentation/altimeter/serviceable", true);
   mk_node(altitude) = fgGetNode("/position/altitude-ft", true);
   mk_node(altitude_agl) = fgGetNode("/position/altitude-agl-ft", true);
+  mk_node(altitude_gear_agl) = fgGetNode("/position/gear-agl-ft", true);
+  mk_node(orientation_roll) = fgGetNode("/orientation/roll-deg", true);
   mk_node(asi_serviceable) = fgGetNode("/instrumentation/airspeed-indicator/serviceable", true);
   mk_node(asi_speed) = fgGetNode("/instrumentation/airspeed-indicator/indicated-speed-kt", true);
   mk_node(autopilot_heading_lock) = fgGetNode("/autopilot/locks/heading", true);
@@ -712,7 +714,10 @@ MK_VIII::ConfigurationModule::read_options_select_group_1 (int value)
 bool
 MK_VIII::ConfigurationModule::read_radio_altitude_input_select (int value)
 {
-  // unimplemented
+  if (value >= 0 && value <= 2)
+    mk->io_handler.conf.use_gear_altitude = true;
+  else
+    mk->io_handler.conf.use_gear_altitude = false;
   return (value >= 0 && value <= 4) || (value >= 251 && value <= 255);
 }
 
@@ -732,7 +737,10 @@ MK_VIII::ConfigurationModule::read_navigation_input_select (int value)
 bool
 MK_VIII::ConfigurationModule::read_attitude_input_select (int value)
 {
-  // unimplemented
+  if (value == 2)
+    mk->io_handler.conf.use_attitude_indicator=true;
+  else
+    mk->io_handler.conf.use_attitude_indicator=false;
   return (value >= 0 && value <= 6) || value == 253 || value == 255;
 }
 
@@ -1144,9 +1152,13 @@ MK_VIII::IOHandler::update_inputs ()
     mk_ainput(barometric_altitude_rate).set(mk_node(vs)->getDoubleValue() * 60);
   if (mk_ainput_feed(radio_altitude))
     {
+      double agl;
+      if (conf.use_gear_altitude)
+        agl = mk_node(altitude_gear_agl)->getDoubleValue();
+      else
+        agl = mk_node(altitude_agl)->getDoubleValue();
       // Some flight models may return negative values when on the
       // ground or after a crash; do not allow them.
-      double agl = mk_node(altitude_agl)->getDoubleValue();
       mk_ainput(radio_altitude).set(SG_MAX2(0.0, agl));
     }
   if (mk_ainput_feed(glideslope_deviation))
@@ -1164,11 +1176,20 @@ MK_VIII::IOHandler::update_inputs ()
     }
   if (mk_ainput_feed(roll_angle))
     {
+      if (conf.use_attitude_indicator)
+      {
+        // read data from attitude indicator instrument (requires vacuum system to work)
       if (mk_node(ai_serviceable)->getBoolValue() && ! mk_node(ai_caged)->getBoolValue())
 	mk_ainput(roll_angle).set(mk_node(ai_roll)->getDoubleValue());
       else
 	mk_ainput(roll_angle).unset();
     }
+      else
+      {
+        // use simulator source
+        mk_ainput(roll_angle).set(mk_node(orientation_roll)->getDoubleValue());
+      }
+    }
   if (mk_ainput_feed(localizer_deviation))
     {
       if (mk_node(nav0_serviceable)->getBoolValue()
@@ -2624,6 +2645,8 @@ MK_VIII::SelfTestHandler::stop ()
 
       button_pressed = false;
       state = STATE_NONE;
+      // reset self-test handler position
+      current=0;
     }
 }
 
@@ -3764,6 +3787,7 @@ MK_VIII::Mode4Handler::update_ab ()
     }
 
   mk_unset_alerts(mk_alert(MODE4_TOO_LOW_FLAPS) | mk_alert(MODE4_TOO_LOW_GEAR));
+  ab_bias=0.0;
 }
 
 void
@@ -3789,6 +3813,7 @@ MK_VIII::Mode4Handler::update_ab_expanded ()
     }
 
   mk_unset_alerts(mk_alert(MODE4AB_TOO_LOW_TERRAIN));
+  ab_expanded_bias=0.0;
 }
 
 void
@@ -3805,7 +3830,10 @@ MK_VIII::Mode4Handler::update_c ()
       && mk_data(radio_altitude).get() < mk_data(terrain_clearance).get())
     handle_alert(mk_alert(MODE4C_TOO_LOW_TERRAIN), mk_data(terrain_clearance).get(), &c_bias);
   else
+  {
     mk_unset_alerts(mk_alert(MODE4C_TOO_LOW_TERRAIN));
+    c_bias=0.0;
+  }
 }
 
 void

src/Instrumentation/mk_viii.hxx

@@ -200,6 +200,8 @@ class MK_VIII : public SGSubsystem
       SGPropertyNode_ptr altimeter_serviceable;
       SGPropertyNode_ptr altitude;
       SGPropertyNode_ptr altitude_agl;
+      SGPropertyNode_ptr altitude_gear_agl;
+      SGPropertyNode_ptr orientation_roll;
       SGPropertyNode_ptr asi_serviceable;
       SGPropertyNode_ptr asi_speed;
       SGPropertyNode_ptr autopilot_heading_lock;
@@ -479,6 +481,8 @@ public:
       bool			alternate_steep_approach;
       bool			use_internal_gps;
       bool			localizer_enabled;
+      bool			use_gear_altitude;
+      bool			use_attitude_indicator;
     } conf;
 
     struct _s_input_feeders
@@ -1358,7 +1362,7 @@ private:
     } conf;
 
     inline Mode4Handler (MK_VIII *device)
-      : mk(device) {}
+      : mk(device),ab_bias(0.0),ab_expanded_bias(0.0),c_bias(0.0) {}
 
     double get_upper_agl (const EnvelopesConfiguration *c);
     void update ();
@@ -1402,7 +1406,7 @@ private:
 
   public:
     inline Mode5Handler (MK_VIII *device)
-      : mk(device) {}
+      : mk(device), soft_bias(0.0) {}
 
     void update ();
   };

src/Instrumentation/od_gauge.cxx

@@ -38,7 +38,6 @@
 #include <osgDB/FileNameUtils>
 
 #include <simgear/scene/util/RenderConstants.hxx>
-#include <simgear/screen/extensions.hxx>
 #include <simgear/debug/logstream.hxx>
 
 #include <Main/globals.hxx>

src/Main/fg_init.cxx

@@ -240,7 +240,9 @@ static string fgScanForOption( const string& option ) {
 
 
 // Read in configuration (files and command line options) but only set
-// fg_root
+// fg_root and aircraft_paths, which are needed *before* do_options() is called
+// in fgInitConfig
+
 bool fgInitFGRoot ( int argc, char **argv ) {
     string root;
 
@@ -291,7 +293,7 @@ bool fgInitFGRoot ( int argc, char **argv ) {
 
     SG_LOG(SG_INPUT, SG_INFO, "fg_root = " << root );
     globals->set_fg_root(root);
-
+    
     return true;
 }
 
@@ -299,6 +301,21 @@ bool fgInitFGRoot ( int argc, char **argv ) {
 // Read in configuration (files and command line options) but only set
 // aircraft
 bool fgInitFGAircraft ( int argc, char **argv ) {
+    
+    string aircraftDir = fgScanForOption("--fg-aircraft=", argc, argv);
+    if (aircraftDir.empty()) {
+      aircraftDir =  fgScanForOption("--fg-aircraft="); 
+    }
+
+    const char* envp = ::getenv("FG_AIRCRAFT");
+    if (aircraftDir.empty() && envp) {
+      globals->append_aircraft_paths(envp);
+    }
+    
+    if (!aircraftDir.empty()) {
+      globals->append_aircraft_paths(aircraftDir);
+    }
+    
     string aircraft;
 
     // First parse command line options looking for --aircraft=, this
@@ -501,13 +518,13 @@ do_options (int argc, char ** argv)
 }
 
 template <class T>
-void fgFindAircraftInDir(const SGPath& dirPath, T* obj, bool (T::*pred)(const SGPath& p))
+bool fgFindAircraftInDir(const SGPath& dirPath, T* obj, bool (T::*pred)(const SGPath& p))
 {
   if (!dirPath.exists()) {
     SG_LOG(SG_GENERAL, SG_WARN, "fgFindAircraftInDir: no such path:" << dirPath.str());
-    return;
+    return false;
   }
-  
+    
   bool recurse = true;
   simgear::Dir dir(dirPath);
   simgear::PathList setFiles(dir.children(simgear::Dir::TYPE_FILE, "-set.xml"));
@@ -520,20 +537,44 @@ void fgFindAircraftInDir(const SGPath& dirPath, T* obj, bool (T::*pred)(const SG
     
     bool done = (obj->*pred)(*p);
     if (done) {
-      return;
+      return true;
     }
   } // of -set.xml iteration
   
-  if (recurse) {
+  if (!recurse) {
-    simgear::PathList subdirs(dir.children(simgear::Dir::TYPE_DIR | simgear::Dir::NO_DOT_OR_DOTDOT));
+    return false;
-    for (p = subdirs.begin(); p != subdirs.end(); ++p) {
+  }
-      if (p->file() == "CVS") {
+  
-        continue;
+  simgear::PathList subdirs(dir.children(simgear::Dir::TYPE_DIR | simgear::Dir::NO_DOT_OR_DOTDOT));
-      }
+  for (p = subdirs.begin(); p != subdirs.end(); ++p) {
-      
+    if (p->file() == "CVS") {
-      fgFindAircraftInDir(*p, obj, pred);
+      continue;
     }
-  } // of recursive case
+    
+    if (fgFindAircraftInDir(*p, obj, pred)) {
+      return true;
+    }
+  } // of subdirs iteration
+  
+  return false;
+}
+
+template <class T>
+void fgFindAircraft(T* obj, bool (T::*pred)(const SGPath& p))
+{
+  const string_list& paths(globals->get_aircraft_paths());
+  string_list::const_iterator it = paths.begin();
+  for (; it != paths.end(); ++it) {
+    bool done = fgFindAircraftInDir(SGPath(*it), obj, pred);
+    if (done) {
+      return;
+    }
+  } // of aircraft paths iteration
+  
+  // if we reach this point, search the default location (always last)
+  SGPath rootAircraft(globals->get_fg_root());
+  rootAircraft.append("Aircraft");
+  fgFindAircraftInDir(rootAircraft, obj, pred);
 }
 
 class FindAndCacheAircraft
@@ -559,11 +600,8 @@ public:
       n->setStringValue(globals->get_fg_root().c_str());
       n->setAttribute(SGPropertyNode::USERARCHIVE, true);
       _cache->removeChildren("aircraft");
-      
+  
-      SGPath aircraftDir(globals->get_fg_root());
+      fgFindAircraft(this, &FindAndCacheAircraft::checkAircraft);
-      aircraftDir.append("Aircraft");
-
-      fgFindAircraftInDir(aircraftDir, this, &FindAndCacheAircraft::checkAircraft);
     }
     
     if (_foundPath.str().empty()) {

src/Main/globals.cxx

@@ -234,6 +234,82 @@ void FGGlobals::set_fg_scenery (const string &scenery)
     } // of path list iteration
 }
 
+void FGGlobals::append_aircraft_path(const std::string& path)
+{
+  SGPath dirPath(path);
+  if (!dirPath.exists()) {
+    SG_LOG(SG_GENERAL, SG_WARN, "aircraft path not found:" << path);
+    return;
+  }
+  
+  fg_aircraft_dirs.push_back(path);
+}
+
+void FGGlobals::append_aircraft_paths(const std::string& path)
+{
+  string_list paths = sgPathSplit(path);
+  for (unsigned int p = 0; p<paths.size(); ++p) {
+    append_aircraft_path(paths[p]);
+  }
+}
+
+SGPath FGGlobals::resolve_aircraft_path(const std::string& branch) const
+{
+  string_list pieces(sgPathBranchSplit(branch));
+  if ((pieces.size() < 3) || (pieces.front() != "Aircraft")) {
+    SG_LOG(SG_AIRCRAFT, SG_ALERT, "resolve_aircraft_path: bad path:" <<  branch);
+    return SGPath();
+  }
+  
+// check current aircraft dir first (takes precedence, allows Generics to be
+// over-riden
+  const char* aircraftDir = fgGetString("/sim/aircraft-dir");
+  string_list aircraftDirPieces(sgPathBranchSplit(aircraftDir));
+  if (!aircraftDirPieces.empty() && (aircraftDirPieces.back() == pieces[1])) {
+    SGPath r(aircraftDir);
+    
+    for (unsigned int i=2; i<pieces.size(); ++i) {
+      r.append(pieces[i]);
+    }
+        
+    if (r.exists()) {
+      std::cout << "using aircraft-dir for:" << r.str() << std::endl;
+      return r;
+    }
+  } // of using aircraft-dir case
+  
+// try each fg_aircraft_dirs in turn
+  for (unsigned int p=0; p<fg_aircraft_dirs.size(); ++p) {
+    SGPath r(fg_aircraft_dirs[p]);
+    r.append(branch);
+    if (r.exists()) {
+      std::cout << "using aircraft directory for:" << r.str() << std::endl;
+      return r;
+    }
+  } // of fg_aircraft_dirs iteration
+
+// finally, try fg_root
+  SGPath r(fg_root);
+  r.append(branch);
+  if (r.exists()) {
+    std::cout << "using FG_ROOT for:" << r.str() << std::endl;
+    return r;
+  }
+
+  SG_LOG(SG_AIRCRAFT, SG_ALERT, "resolve_aircraft_path: failed to resolve:" << branch);
+  return SGPath();
+}
+
+SGPath FGGlobals::resolve_maybe_aircraft_path(const std::string& branch) const
+{
+  if (branch.find("Aircraft/") == 0) {
+    return resolve_aircraft_path(branch);
+  } else {
+    SGPath r(fg_root);
+    r.append(branch);
+    return r;
+  }
+}
 
 FGRenderer *
 FGGlobals::get_renderer () const

src/Main/globals.hxx

@@ -27,6 +27,7 @@
 #include <simgear/compiler.h>
 #include <simgear/props/props.hxx>
 #include <simgear/structure/subsystem_mgr.hxx>
+#include <simgear/misc/sg_path.hxx>
 
 #include <vector>
 #include <string>
@@ -181,6 +182,8 @@ private:
     //Mulitplayer managers
     FGMultiplayMgr *multiplayer_mgr;
 
+    /// roots of Aircraft trees
+    string_list fg_aircraft_dirs;
 public:
 
     FGGlobals();
@@ -212,6 +215,26 @@ public:
     inline const string_list &get_fg_scenery () const { return fg_scenery; }
     void set_fg_scenery (const std::string &scenery);
 
+    const string_list& get_aircraft_paths() const { return fg_aircraft_dirs; }
+    void append_aircraft_path(const std::string& path);
+    void append_aircraft_paths(const std::string& path);
+    
+    /**
+     * Given a path to an aircraft-related resource file, resolve it
+     * against the appropriate root. This means looking at the location
+     * defined by /sim/aircraft-dir, and then aircraft_path in turn,
+     * finishing with fg_root/Aircraft.
+     *
+     * if the path could not be resolved, an empty path is returned.
+     */
+    SGPath resolve_aircraft_path(const std::string& branch) const;
+    
+    /**
+     * Same as above, but test for non 'Aircraft/' branch paths, and
+     * always resolve them against fg_root.
+     */
+    SGPath resolve_maybe_aircraft_path(const std::string& branch) const;
+    
     inline const std::string &get_browser () const { return browser; }
     void set_browser (const std::string &b) { browser = b; }
 

src/Main/main.cxx

@@ -342,7 +342,7 @@ static void fgMainLoop( void ) {
     // implementation is an AI model and depends on that
     globals->get_multiplayer_mgr()->Update();
 
-#if ENABLE_ATCDCL
+#if ENABLE_ATCDCL  
     // Run ATC subsystem
     if (fgGetBool("/sim/atc/enabled"))
         globals->get_ATC_mgr()->update(delta_time_sec);
@@ -493,6 +493,20 @@ struct GeneralInitOperation : public GraphicsContextOperation
         SG_LOG ( SG_GENERAL, SG_INFO, "Depth buffer bits = " << tmp );
     }
 };
+
+
+osg::Node* load_panel(SGPropertyNode *n)
+{
+    osg::Geode* geode = new osg::Geode;
+    geode->addDrawable(new FGPanelNode(n));
+    return geode;
+}
+
+SGPath resolve_path(const std::string& s)
+{
+  return globals->resolve_maybe_aircraft_path(s);
+}
+
 }
 
 // This is the top level master main function that is registered as
@@ -573,8 +587,10 @@ static void fgIdleFunction ( void ) {
         ////////////////////////////////////////////////////////////////////
         globals->set_matlib( new SGMaterialLib );
         simgear::SGModelLib::init(globals->get_fg_root());
-
+        simgear::SGModelLib::setPropRoot(globals->get_props());
-
+        simgear::SGModelLib::setResolveFunc(resolve_path);
+        simgear::SGModelLib::setPanelFunc(load_panel);
+        
         ////////////////////////////////////////////////////////////////////
         // Initialize the TG scenery subsystem.
         ////////////////////////////////////////////////////////////////////

src/Main/options.cxx

@@ -114,6 +114,7 @@ fgSetDefaults ()
 	// Otherwise, default to Scenery being in $FG_ROOT/Scenery
 	globals->set_fg_scenery("");
     }
+        
 				// Position (deliberately out of range)
     fgSetDouble("/position/longitude-deg", 9999.0);
     fgSetDouble("/position/latitude-deg", 9999.0);
@@ -772,7 +773,7 @@ fgOptRoc( const char *arg )
 static int
 fgOptFgRoot( const char *arg )
 {
-    globals->set_fg_root(arg);
+    // this option is dealt with by fgInitFGRoot
     return FG_OPTIONS_OK;
 }
 
@@ -783,6 +784,13 @@ fgOptFgScenery( const char *arg )
     return FG_OPTIONS_OK;
 }
 
+static int
+fgOptFgAircraft(const char* arg)
+{
+  // this option is dealt with by fgInitFGAircraft
+  return FG_OPTIONS_OK;
+}
+
 static int
 fgOptFov( const char *arg )
 {
@@ -1339,6 +1347,7 @@ struct OptionDesc {
     {"roc",                          true,  OPTION_FUNC,   "", false, "", fgOptRoc },
     {"fg-root",                      true,  OPTION_FUNC,   "", false, "", fgOptFgRoot },
     {"fg-scenery",                   true,  OPTION_FUNC,   "", false, "", fgOptFgScenery },
+    {"fg-aircraft",                  true,  OPTION_FUNC,   "", false, "", fgOptFgAircraft },
     {"fdm",                          true,  OPTION_STRING, "/sim/flight-model", false, "", 0 },
     {"aero",                         true,  OPTION_STRING, "/sim/aero", false, "", 0 },
     {"aircraft-dir",                 true,  OPTION_STRING, "/sim/aircraft-dir", false, "", 0 },
@@ -1622,7 +1631,7 @@ fgParseArgs (int argc, char **argv)
     bool verbose = false;
     bool help = false;
 
-    SG_LOG(SG_GENERAL, SG_INFO, "Processing command line arguments");
+    SG_LOG(SG_GENERAL, SG_ALERT, "Processing command line arguments");
 
     for (int i = 1; i < argc; i++) {
         string arg = argv[i];

src/Main/renderer.cxx

@@ -57,7 +57,6 @@
 #include <osgDB/WriteFile>
 
 #include <simgear/math/SGMath.hxx>
-#include <simgear/screen/extensions.hxx>
 #include <simgear/scene/material/matlib.hxx>
 #include <simgear/scene/model/animation.hxx>
 #include <simgear/scene/model/placement.hxx>

src/Main/renderer.hxx

@@ -2,7 +2,6 @@
 #ifndef __FG_RENDERER_HXX
 #define __FG_RENDERER_HXX 1
 
-#include <simgear/screen/extensions.hxx>
 #include <simgear/scene/util/SGPickCallback.hxx>
 
 #include <osg/ref_ptr>

src/Main/splash.cxx

@@ -197,9 +197,10 @@ static osg::Node* fgCreateSplashCamera()
     tpath.append( "Textures/Splash" );
     tpath.concat( num_str );
     tpath.concat( ".png" );
-  } else
+  } else {
-    tpath.append( splash_texture );
+    tpath = globals->resolve_maybe_aircraft_path(splash_texture);
-
+  }
+  
   osg::Texture2D* splashTexture = new osg::Texture2D;
   splashTexture->setImage(osgDB::readImageFile(tpath.c_str()));
 

src/Model/model_panel.cxx

@@ -22,15 +22,6 @@
 using std::vector;
 
 using namespace simgear;
-
-static
-osg::Node* load_panel(SGPropertyNode *n)
-{
-    osg::Geode* geode = new osg::Geode;
-    geode->addDrawable(new FGPanelNode(n));
-    return geode;
-}
-
 
 ////////////////////////////////////////////////////////////////////////
 // Global functions.
@@ -39,7 +30,7 @@ osg::Node* load_panel(SGPropertyNode *n)
 osg::Node *
 fgLoad3DModelPanel(const string &path, SGPropertyNode *prop_root)
 {
-    osg::Node* node = SGModelLib::loadModel(path, prop_root, load_panel);
+    osg::Node* node = SGModelLib::loadModel(path, prop_root);
     if (node)
         node->setNodeMask(~SG_NODEMASK_TERRAIN_BIT);
     return node;

src/Scripting/NasalSys.cxx

@@ -750,8 +750,7 @@ void FGNasalSys::loadPropertyScripts()
         while((fn = n->getChild("file", j)) != NULL) {
             file_specified = true;
             const char* file = fn->getStringValue();
-            SGPath p(globals->get_fg_root());
+            SGPath p = globals->resolve_maybe_aircraft_path(file);
-            p.append(file);
             loadModule(p, module);
             j++;
         }

src/Sound/fg_fx.cxx

@@ -69,13 +69,12 @@ FGFX::init()
     SGPropertyNode *node = fgGetNode("/sim/sound", true);
 
     string path_str = node->getStringValue("path");
-    SGPath path( globals->get_fg_root() );
     if (path_str.empty()) {
         SG_LOG(SG_GENERAL, SG_ALERT, "No path in /sim/sound/path");
         return;
     }
-
+    
-    path.append(path_str.c_str());
+    SGPath path = globals->resolve_aircraft_path(path_str);
     SG_LOG(SG_GENERAL, SG_INFO, "Reading sound " << node->getName()
            << " from " << path.str());
 

src/Systems/system_mgr.cxx

@@ -34,8 +34,7 @@ FGSystemMgr::FGSystemMgr ()
     SGPropertyNode *path_n = fgGetNode("/sim/systems/path");
 
     if (path_n) {
-        SGPath config( globals->get_fg_root() );
+        SGPath config = globals->resolve_aircraft_path(path_n->getStringValue());
-        config.append( path_n->getStringValue() );
 
         SG_LOG( SG_ALL, SG_INFO, "Reading systems from "
                 << config.str() );

src/Traffic/SchedFlight.cxx

@@ -33,7 +33,6 @@
  *
  * TODO:
  * - Check the code for known portability issues
- * - Find an alternative for the depricated Point3D class
  *
  *****************************************************************************/
 

src/Traffic/Schedule.cxx

@@ -496,7 +496,6 @@ bool compareSchedules(FGAISchedule*a, FGAISchedule*b)
 //   double course;
 //   double dist;
 
-//   Point3D temp;
 //   time_t 
 //     totalTimeEnroute, 
 //     elapsedTimeEnroute;

tests/Makefile.am

@@ -1,6 +1,6 @@
 bin_PROGRAMS = est-epsilon gl-info alcinfo
 
-noinst_PROGRAMS = test-gethostname test-mktime test-text test-up test-env-map
+noinst_PROGRAMS = test-gethostname test-mktime test-text test-env-map
 
 if HAVE_FRAMEWORK_PLIB
 test_up_LDFLAGS = $(plib_FRAMEWORK)
@@ -26,5 +26,3 @@ test_mktime_SOURCES = test-mktime.cxx
 
 test_text_SOURCES = test-text.cxx
 
-test_up_SOURCES = test-up.cxx
-test_up_LDADD = $(test_up_PLIB_LIBS) -lsgmath -lsgxml -lsgmisc -lsgdebug -lsgstructure -lsgtiming -lz $(base_LIBS)