Set "/sim/fghome-readonly" to false also for Windows.
[fg:hoorays-flightgear.git] / src / Main / fg_init.cxx
1 // fg_init.cxx -- Flight Gear top level initialization routines
2 //
3 // Written by Curtis Olson, started August 1997.
4 //
5 // Copyright (C) 1997  Curtis L. Olson  - http://www.flightgear.org/~curt
6 //
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License as
9 // published by the Free Software Foundation; either version 2 of the
10 // License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 // General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 //
21 // $Id$
22
23
24 #ifdef HAVE_CONFIG_H
25 #  include <config.h>
26 #endif
27
28 #include <simgear/compiler.h>
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>             // strcmp()
33
34 #if defined(SG_WINDOWS)
35 #  include <io.h>               // isatty()
36 #  include <process.h>          // _getpid()
37 #  include <Windows.h>
38 #  define isatty _isatty
39 #else
40 // for open() and options
41 #  include <sys/types.h>        
42 #  include <sys/stat.h>
43 #  include <fcntl.h>
44 #endif
45
46 #include <string>
47
48 #include <boost/algorithm/string/compare.hpp>
49 #include <boost/algorithm/string/predicate.hpp>
50
51 #include <osgViewer/Viewer>
52
53 #include <simgear/canvas/Canvas.hxx>
54 #include <simgear/constants.h>
55 #include <simgear/debug/logstream.hxx>
56 #include <simgear/structure/exception.hxx>
57 #include <simgear/structure/event_mgr.hxx>
58 #include <simgear/structure/SGPerfMon.hxx>
59 #include <simgear/misc/sg_path.hxx>
60 #include <simgear/misc/sg_dir.hxx>
61 #include <simgear/misc/sgstream.hxx>
62 #include <simgear/misc/strutils.hxx>
63 #include <simgear/props/props_io.hxx>
64 #include <simgear/scene/tsync/terrasync.hxx>
65
66 #include <simgear/scene/model/modellib.hxx>
67 #include <simgear/scene/material/matlib.hxx>
68 #include <simgear/scene/material/Effect.hxx>
69 #include <simgear/scene/model/particles.hxx>
70 #include <simgear/scene/tsync/terrasync.hxx>
71
72 #include <Aircraft/controls.hxx>
73 #include <Aircraft/replay.hxx>
74 #include <Aircraft/FlightHistory.hxx>
75 #include <Airports/runways.hxx>
76 #include <Airports/airport.hxx>
77 #include <Airports/dynamics.hxx>
78
79 #include <AIModel/AIManager.hxx>
80
81 #include <ATCDCL/ATISmgr.hxx>
82 #include <ATC/atc_mgr.hxx>
83
84 #include <Autopilot/route_mgr.hxx>
85 #include <Autopilot/autopilotgroup.hxx>
86
87 #include <Cockpit/panel.hxx>
88 #include <Cockpit/panel_io.hxx>
89
90 #include <Canvas/canvas_mgr.hxx>
91 #include <Canvas/gui_mgr.hxx>
92 #include <Canvas/FGCanvasSystemAdapter.hxx>
93 #include <GUI/new_gui.hxx>
94 #include <GUI/MessageBox.hxx>
95 #include <Input/input.hxx>
96 #include <Instrumentation/instrument_mgr.hxx>
97 #include <Model/acmodel.hxx>
98 #include <Model/modelmgr.hxx>
99 #include <AIModel/submodel.hxx>
100 #include <AIModel/AIManager.hxx>
101 #include <Navaids/navdb.hxx>
102 #include <Navaids/navlist.hxx>
103 #include <Scenery/scenery.hxx>
104 #include <Scenery/tilemgr.hxx>
105 #include <Scripting/NasalSys.hxx>
106 #include <Sound/voice.hxx>
107 #include <Sound/soundmanager.hxx>
108 #include <Systems/system_mgr.hxx>
109 #include <Time/light.hxx>
110 #include <Time/TimeManager.hxx>
111
112 #include <Traffic/TrafficMgr.hxx>
113 #include <MultiPlayer/multiplaymgr.hxx>
114 #include <FDM/fdm_shell.hxx>
115 #include <Environment/ephemeris.hxx>
116 #include <Environment/environment_mgr.hxx>
117 #include <Viewer/renderer.hxx>
118 #include <Viewer/viewmgr.hxx>
119 #include <Viewer/FGEventHandler.hxx>
120 #include <Navaids/NavDataCache.hxx>
121 #include <Instrumentation/HUD/HUD.hxx>
122 #include <Cockpit/cockpitDisplayManager.hxx>
123 #include <Network/HTTPClient.hxx>
124 #include <Network/fgcom.hxx>
125
126 #include <Viewer/CameraGroup.hxx>
127
128 #include "fg_init.hxx"
129 #include "fg_io.hxx"
130 #include "fg_commands.hxx"
131 #include "fg_props.hxx"
132 #include "FGInterpolator.hxx"
133 #include "options.hxx"
134 #include "globals.hxx"
135 #include "logger.hxx"
136 #include "main.hxx"
137 #include "positioninit.hxx"
138 #include "util.hxx"
139 #include "AircraftDirVisitorBase.hxx"
140
141 #if defined(SG_MAC)
142 #include <GUI/CocoaHelpers.h> // for Mac impl of platformDefaultDataPath()
143 #endif
144
145 //#define NEW_RESET 1
146
147 using std::string;
148 using std::endl;
149 using std::cerr;
150 using std::cout;
151 using namespace boost::algorithm;
152
153 extern osg::ref_ptr<osgViewer::Viewer> viewer;
154
155 // Return the current base package version
156 string fgBasePackageVersion() {
157     SGPath base_path( globals->get_fg_root() );
158     base_path.append("version");
159     if (!base_path.exists()) {
160         return string();
161     }
162     
163     sg_gzifstream in( base_path.str() );
164     if (!in.is_open()) {
165         return string();
166     }
167
168     string version;
169     in >> version;
170
171     return version;
172 }
173
174 class FindAndCacheAircraft : public AircraftDirVistorBase
175 {
176 public:
177   FindAndCacheAircraft(SGPropertyNode* autoSave)
178   {
179     _cache = autoSave->getNode("sim/startup/path-cache", true);
180   }
181   
182   bool loadAircraft()
183   {
184     std::string aircraft = fgGetString( "/sim/aircraft", "");
185     if (aircraft.empty()) {
186         flightgear::fatalMessageBox("No aircraft", "No aircraft was specified");
187       SG_LOG(SG_GENERAL, SG_ALERT, "no aircraft specified");
188       return false;
189     }
190     
191     _searchAircraft = aircraft + "-set.xml";
192     std::string aircraftDir = fgGetString("/sim/aircraft-dir", "");
193     if (!aircraftDir.empty()) {
194       // aircraft-dir was set, skip any searching at all, if it's valid
195       simgear::Dir acPath(aircraftDir);
196       SGPath setFile = acPath.file(_searchAircraft);
197       if (setFile.exists()) {
198         SG_LOG(SG_GENERAL, SG_INFO, "found aircraft in dir: " << aircraftDir );
199         
200         try {
201           readProperties(setFile.str(), globals->get_props());
202         } catch ( const sg_exception &e ) {
203           SG_LOG(SG_INPUT, SG_ALERT, "Error reading aircraft: " << e.getFormattedMessage());
204             flightgear::fatalMessageBox("Error reading aircraft",
205                                         "An error occured reading the requested aircraft (" + aircraft + ")",
206                                         e.getFormattedMessage());
207           return false;
208         }
209         
210         return true;
211       } else {
212         SG_LOG(SG_GENERAL, SG_ALERT, "aircraft '" << _searchAircraft << 
213                "' not found in specified dir:" << aircraftDir);
214           flightgear::fatalMessageBox("Aircraft not found",
215                                       "The requested aircraft '" + aircraft + "' could not be found in the specified location.",
216                                       aircraftDir);
217         return false;
218       }
219     }
220     
221     if (!checkCache()) {
222       // prepare cache for re-scan
223       SGPropertyNode *n = _cache->getNode("fg-root", true);
224       n->setStringValue(globals->get_fg_root().c_str());
225       n->setAttribute(SGPropertyNode::USERARCHIVE, true);
226       n = _cache->getNode("fg-aircraft", true);
227       n->setStringValue(getAircraftPaths().c_str());
228       n->setAttribute(SGPropertyNode::USERARCHIVE, true);
229       _cache->removeChildren("aircraft");
230   
231         visitAircraftPaths();
232     }
233     
234     if (_foundPath.str().empty()) {
235       SG_LOG(SG_GENERAL, SG_ALERT, "Cannot find specified aircraft: " << aircraft );
236         flightgear::fatalMessageBox("Aircraft not found",
237                                     "The requested aircraft '" + aircraft + "' could not be found in any of the search paths");
238
239       return false;
240     }
241     
242     SG_LOG(SG_GENERAL, SG_INFO, "Loading aircraft -set file from:" << _foundPath.str());
243     fgSetString( "/sim/aircraft-dir", _foundPath.dir().c_str());
244     if (!_foundPath.exists()) {
245       SG_LOG(SG_GENERAL, SG_ALERT, "Unable to find -set file:" << _foundPath.str());
246       return false;
247     }
248     
249     try {
250       readProperties(_foundPath.str(), globals->get_props());
251     } catch ( const sg_exception &e ) {
252       SG_LOG(SG_INPUT, SG_ALERT, "Error reading aircraft: " << e.getFormattedMessage());
253         flightgear::fatalMessageBox("Error reading aircraft",
254                                     "An error occured reading the requested aircraft (" + aircraft + ")",
255                                     e.getFormattedMessage());
256       return false;
257     }
258     
259     return true;
260   }
261   
262 private:
263   SGPath getAircraftPaths() {
264     string_list pathList = globals->get_aircraft_paths();
265     SGPath aircraftPaths;
266     string_list::const_iterator it = pathList.begin();
267     if (it != pathList.end()) {
268         aircraftPaths.set(*it);
269         it++;
270     }
271     for (; it != pathList.end(); ++it) {
272         aircraftPaths.add(*it);
273     }
274     return aircraftPaths;
275   }
276   
277   bool checkCache()
278   {
279     if (globals->get_fg_root() != _cache->getStringValue("fg-root", "")) {
280       return false; // cache mismatch
281     }
282
283     if (getAircraftPaths().str() != _cache->getStringValue("fg-aircraft", "")) {
284       return false; // cache mismatch
285     }
286     
287     vector<SGPropertyNode_ptr> cache = _cache->getChildren("aircraft");
288     for (unsigned int i = 0; i < cache.size(); i++) {
289       const char *name = cache[i]->getStringValue("file", "");
290       if (!boost::equals(_searchAircraft, name, is_iequal())) {
291         continue;
292       }
293       
294       SGPath xml(cache[i]->getStringValue("path", ""));
295       xml.append(name);
296       if (xml.exists()) {
297         _foundPath = xml;
298         return true;
299       } 
300       
301       return false;
302     } // of aircraft in cache iteration
303     
304     return false;
305   }
306   
307   virtual VisitResult visit(const SGPath& p)
308   {
309     // create cache node
310     int i = 0;
311     while (1) {
312         if (!_cache->getChild("aircraft", i++, false))
313             break;
314     }
315     
316     SGPropertyNode *n, *entry = _cache->getChild("aircraft", --i, true);
317
318     std::string fileName(p.file());
319     n = entry->getNode("file", true);
320     n->setStringValue(fileName);
321     n->setAttribute(SGPropertyNode::USERARCHIVE, true);
322
323     n = entry->getNode("path", true);
324     n->setStringValue(p.dir());
325     n->setAttribute(SGPropertyNode::USERARCHIVE, true);
326
327     if ( boost::equals(fileName, _searchAircraft.c_str(), is_iequal()) ) {
328         _foundPath = p;
329         return VISIT_DONE;
330     }
331
332     return VISIT_CONTINUE;
333   }
334   
335   std::string _searchAircraft;
336   SGPath _foundPath;
337   SGPropertyNode* _cache;
338 };
339
340 #ifdef _WIN32
341 static SGPath platformDefaultDataPath()
342 {
343   char *envp = ::getenv( "APPDATA" );
344   SGPath config( envp );
345   config.append( "flightgear.org" );
346   return config;
347 }
348
349 #elif defined(SG_MAC)
350
351 // platformDefaultDataPath defined in GUI/CocoaHelpers.h
352
353 #else
354 static SGPath platformDefaultDataPath()
355 {
356   return SGPath::home() / ".fgfs";
357 }
358 #endif
359
360 bool fgInitHome()
361 {
362   SGPath dataPath = SGPath::fromEnv("FG_HOME", platformDefaultDataPath());
363   globals->set_fg_home(dataPath.c_str());
364     
365     simgear::Dir fgHome(dataPath);
366     if (!fgHome.exists()) {
367         fgHome.create(0755);
368     }
369     
370     if (!fgHome.exists()) {
371         flightgear::fatalMessageBox("Problem setting up user data",
372                                     "Unable to create the user-data storage folder at: '"
373                                     + dataPath.str() + "'");
374         return false;
375     }
376     
377     if (fgGetBool("/sim/fghome-readonly", false)) {
378         // user / config forced us into readonly mode, fine
379         SG_LOG(SG_GENERAL, SG_INFO, "Running with FG_HOME readonly");
380         return true;
381     }
382     
383 // write our PID, and check writeability
384     SGPath pidPath(dataPath, "fgfs.pid");
385     if (pidPath.exists()) {
386         SG_LOG(SG_GENERAL, SG_INFO, "flightgear instance already running, switching to FG_HOME read-only.");
387         // set a marker property so terrasync/navcache don't try to write
388         // from secondary instances
389         fgSetBool("/sim/fghome-readonly", true);
390         return true;
391     }
392     
393     char buf[16];
394     bool result = false;
395 #if defined(SG_WINDOWS)
396     size_t len = snprintf(buf, 16, "%d", _getpid());
397
398     HANDLE f = CreateFileA(pidPath.c_str(), GENERIC_READ | GENERIC_WRITE, 
399                                                    FILE_SHARE_READ, /* sharing */
400                            NULL, /* security attributes */
401                            CREATE_NEW, /* error if already exists */
402                            FILE_FLAG_DELETE_ON_CLOSE,
403                                                    NULL /* template */);
404     
405     result = (f != INVALID_HANDLE_VALUE);
406     if (result) {
407                 DWORD written;
408         WriteFile(f, buf, len, &written, NULL /* overlapped */);
409     }
410 #else
411     // POSIX, do open+unlink trick to the file is deleted on exit, even if we
412     // crash or exit(-1)
413     ssize_t len = snprintf(buf, 16, "%d", getpid());
414     int fd = ::open(pidPath.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0644);
415     if (fd >= 0) {
416         result = ::write(fd, buf, len) == len;
417         if( ::unlink(pidPath.c_str()) != 0 ) // delete file when app quits
418           result = false;
419     }
420 #endif
421
422     fgSetBool("/sim/fghome-readonly", false);
423
424     if (!result) {
425         flightgear::fatalMessageBox("File permissions problem",
426                                     "Can't write to user-data storage folder, check file permissions and FG_HOME.",
427                                     "User-data at:" + dataPath.str());
428     }
429     return result;
430 }
431
432 // Read in configuration (file and command line)
433 int fgInitConfig ( int argc, char **argv, bool reinit )
434 {
435     SGPath dataPath = globals->get_fg_home();
436     
437     simgear::Dir exportDir(simgear::Dir(dataPath).file("Export"));
438     if (!exportDir.exists()) {
439       exportDir.create(0777);
440     }
441     
442     // Set /sim/fg-home and don't allow malign code to override it until
443     // Nasal security is set up.  Use FG_HOME if necessary.
444     SGPropertyNode *home = fgGetNode("/sim", true);
445     home->removeChild("fg-home", 0, false);
446     home = home->getChild("fg-home", 0, true);
447     home->setStringValue(dataPath.c_str());
448     home->setAttribute(SGPropertyNode::WRITE, false);
449   
450     fgSetDefaults();
451     flightgear::Options* options = flightgear::Options::sharedInstance();
452     if (!reinit) {
453         options->init(argc, argv, dataPath);
454     }
455     
456     bool loadDefaults = options->shouldLoadDefaultConfig();
457     if (loadDefaults) {
458       // Read global preferences from $FG_ROOT/preferences.xml
459       SG_LOG(SG_INPUT, SG_INFO, "Reading global preferences");
460       fgLoadProps("preferences.xml", globals->get_props());
461       SG_LOG(SG_INPUT, SG_INFO, "Finished Reading global preferences");
462         
463       // do not load user settings when reset to default is requested, or if
464       // told to explicitly ignore
465       if (options->isOptionSet("restore-defaults") || options->isOptionSet("ignore-autosave"))
466       {
467           SG_LOG(SG_ALL, SG_ALERT, "Ignoring user settings. Restoring defaults.");
468       }
469       else
470       {
471           globals->loadUserSettings(dataPath);
472       }
473     } else {
474       SG_LOG(SG_GENERAL, SG_INFO, "not reading default configuration files");
475     }// of no-default-config selected
476     
477     return flightgear::FG_OPTIONS_OK;
478 }
479
480 int fgInitAircraft(bool reinit)
481 {
482     // Scan user config files and command line for a specified aircraft.
483     if (!reinit) {
484         flightgear::Options::sharedInstance()->initAircraft();
485     }
486     
487     FindAndCacheAircraft f(globals->get_props());
488     if (!f.loadAircraft()) {
489         return flightgear::FG_OPTIONS_ERROR;
490     }
491     
492     return flightgear::FG_OPTIONS_OK;
493 }
494
495 /**
496  * Initialize vor/ndb/ils/fix list management and query systems (as
497  * well as simple airport db list)
498  * This is called multiple times in the case of a cache rebuild,
499  * to allow lengthy caching to take place in the background, without
500  * blocking the main/UI thread.
501  */
502 bool
503 fgInitNav ()
504 {
505   flightgear::NavDataCache* cache = flightgear::NavDataCache::instance();
506   static bool doingRebuild = false;
507   if (doingRebuild || cache->isRebuildRequired()) {
508     doingRebuild = true;
509     bool finished = cache->rebuild();
510     if (!finished) {
511       // sleep to give the rebuild thread more time
512       SGTimeStamp::sleepForMSec(50);
513       return false;
514     }
515   }
516   
517   FGTACANList *channellist = new FGTACANList;
518   globals->set_channellist( channellist );
519   
520   SGPath path(globals->get_fg_root());
521   path.append( "Navaids/TACAN_freq.dat" );
522   flightgear::loadTacan(path, channellist);
523   
524   return true;
525 }
526
527 // General house keeping initializations
528 bool fgInitGeneral() {
529     string root;
530
531     SG_LOG( SG_GENERAL, SG_INFO, "General Initialization" );
532     SG_LOG( SG_GENERAL, SG_INFO, "======= ==============" );
533
534     root = globals->get_fg_root();
535     if ( ! root.length() ) {
536         // No root path set? Then bail ...
537         SG_LOG( SG_GENERAL, SG_ALERT,
538                 "Cannot continue without a path to the base package "
539                 << "being defined." );
540         return false;
541     }
542     SG_LOG( SG_GENERAL, SG_INFO, "FG_ROOT = " << '"' << root << '"' << endl );
543
544     // Note: browser command is hard-coded for Mac/Windows, so this only affects other platforms
545     globals->set_browser(fgGetString("/sim/startup/browser-app", WEB_BROWSER));
546     fgSetString("/sim/startup/browser-app", globals->get_browser());
547
548     simgear::Dir cwd(simgear::Dir::current());
549     SGPropertyNode *curr = fgGetNode("/sim", true);
550     curr->removeChild("fg-current", 0, false);
551     curr = curr->getChild("fg-current", 0, true);
552     curr->setStringValue(cwd.path().str());
553     curr->setAttribute(SGPropertyNode::WRITE, false);
554
555     fgSetBool("/sim/startup/stdout-to-terminal", isatty(1) != 0 );
556     fgSetBool("/sim/startup/stderr-to-terminal", isatty(2) != 0 );
557     return true;
558 }
559
560 // Write various configuraton values out to the logs
561 void fgOutputSettings()
562 {    
563     SG_LOG( SG_GENERAL, SG_INFO, "Configuration State" );
564     SG_LOG( SG_GENERAL, SG_INFO, "======= ==============" );
565     
566     SG_LOG( SG_GENERAL, SG_INFO, "aircraft-dir = " << '"' << fgGetString("/sim/aircraft-dir") << '"' );
567     SG_LOG( SG_GENERAL, SG_INFO, "fghome-dir = " << '"' << globals->get_fg_home() << '"');
568     SG_LOG( SG_GENERAL, SG_INFO, "aircraft-dir = " << '"' << fgGetString("/sim/aircraft-dir") << '"');
569     
570     SG_LOG( SG_GENERAL, SG_INFO, "aircraft-search-paths = \n\t" << simgear::strutils::join(globals->get_aircraft_paths(), "\n\t") );
571     SG_LOG( SG_GENERAL, SG_INFO, "scenery-search-paths = \n\t" << simgear::strutils::join(globals->get_fg_scenery(), "\n\t") );
572 }
573
574 // This is the top level init routine which calls all the other
575 // initialization routines.  If you are adding a subsystem to flight
576 // gear, its initialization call should located in this routine.
577 // Returns non-zero if a problem encountered.
578 void fgCreateSubsystems(bool duringReset) {
579
580     SG_LOG( SG_GENERAL, SG_INFO, "Creating Subsystems");
581     SG_LOG( SG_GENERAL, SG_INFO, "========== ==========");
582
583     ////////////////////////////////////////////////////////////////////
584     // Initialize the sound subsystem.
585     ////////////////////////////////////////////////////////////////////
586     // Sound manager uses an own subsystem group "SOUND" which is the last
587     // to be updated in every loop.
588     // Sound manager is updated last so it can use the CPU while the GPU
589     // is processing the scenery (doubled the frame-rate for me) -EMH-
590     globals->add_subsystem("sound", new FGSoundManager, SGSubsystemMgr::SOUND);
591
592     ////////////////////////////////////////////////////////////////////
593     // Initialize the event manager subsystem.
594     ////////////////////////////////////////////////////////////////////
595
596     globals->get_event_mgr()->init();
597     globals->get_event_mgr()->setRealtimeProperty(fgGetNode("/sim/time/delta-realtime-sec", true));
598
599     ////////////////////////////////////////////////////////////////////
600     // Initialize the property interpolator subsystem. Put into the INIT
601     // group because the "nasal" subsystem may need it at GENERAL take-down.
602     ////////////////////////////////////////////////////////////////////
603     FGInterpolator* interp = new FGInterpolator;
604     interp->setRealtimeProperty(fgGetNode("/sim/time/delta-realtime-sec", true));
605     globals->add_subsystem("prop-interpolator", interp, SGSubsystemMgr::INIT);
606     SGPropertyNode::setInterpolationMgr(interp);
607
608     ////////////////////////////////////////////////////////////////////
609     // Add the FlightGear property utilities.
610     ////////////////////////////////////////////////////////////////////
611     globals->add_subsystem("properties", new FGProperties);
612
613
614     ////////////////////////////////////////////////////////////////////
615     // Add the performance monitoring system.
616     ////////////////////////////////////////////////////////////////////
617     globals->add_subsystem("performance-mon",
618             new SGPerformanceMonitor(globals->get_subsystem_mgr(),
619                                      fgGetNode("/sim/performance-monitor", true)));
620
621     ////////////////////////////////////////////////////////////////////
622     // Initialize the material property subsystem.
623     ////////////////////////////////////////////////////////////////////
624
625     SGPath mpath( globals->get_fg_root() );
626     mpath.append( fgGetString("/sim/rendering/materials-file") );
627     if ( ! globals->get_matlib()->load(globals->get_fg_root(), mpath.str(),
628             globals->get_props()) ) {
629        throw sg_io_exception("Error loading materials file", mpath);
630     }
631     
632     globals->add_subsystem( "http", new FGHTTPClient );
633     
634     ////////////////////////////////////////////////////////////////////
635     // Initialize the scenery management subsystem.
636     ////////////////////////////////////////////////////////////////////
637
638     globals->get_scenery()->get_scene_graph()
639         ->addChild(simgear::Particles::getCommonRoot());
640     simgear::GlobalParticleCallback::setSwitch(fgGetNode("/sim/rendering/particles", true));
641
642     ////////////////////////////////////////////////////////////////////
643     // Initialize the flight model subsystem.
644     ////////////////////////////////////////////////////////////////////
645
646     globals->add_subsystem("flight", new FDMShell, SGSubsystemMgr::FDM);
647
648     ////////////////////////////////////////////////////////////////////
649     // Initialize the weather subsystem.
650     ////////////////////////////////////////////////////////////////////
651
652     // Initialize the weather modeling subsystem
653     globals->add_subsystem("environment", new FGEnvironmentMgr);
654     globals->add_subsystem("ephemeris", new Ephemeris);
655     
656     ////////////////////////////////////////////////////////////////////
657     // Initialize the aircraft systems and instrumentation (before the
658     // autopilot.)
659     ////////////////////////////////////////////////////////////////////
660
661     globals->add_subsystem("systems", new FGSystemMgr, SGSubsystemMgr::FDM);
662     globals->add_subsystem("instrumentation", new FGInstrumentMgr, SGSubsystemMgr::FDM);
663     globals->add_subsystem("hud", new HUD, SGSubsystemMgr::DISPLAY);
664     globals->add_subsystem("cockpit-displays", new flightgear::CockpitDisplayManager, SGSubsystemMgr::DISPLAY);
665   
666     ////////////////////////////////////////////////////////////////////
667     // Initialize the XML Autopilot subsystem.
668     ////////////////////////////////////////////////////////////////////
669
670     globals->add_subsystem( "xml-autopilot", FGXMLAutopilotGroup::createInstance("autopilot"), SGSubsystemMgr::FDM );
671     globals->add_subsystem( "xml-proprules", FGXMLAutopilotGroup::createInstance("property-rule"), SGSubsystemMgr::GENERAL );
672     globals->add_subsystem( "route-manager", new FGRouteMgr );
673
674     ////////////////////////////////////////////////////////////////////
675     // Initialize the Input-Output subsystem
676     ////////////////////////////////////////////////////////////////////
677     globals->add_subsystem( "io", new FGIO );
678   
679     ////////////////////////////////////////////////////////////////////
680     // Create and register the logger.
681     ////////////////////////////////////////////////////////////////////
682     
683     globals->add_subsystem("logger", new FGLogger);
684
685     ////////////////////////////////////////////////////////////////////
686     // Create and register the XML GUI.
687     ////////////////////////////////////////////////////////////////////
688
689     globals->add_subsystem("gui", new NewGUI, SGSubsystemMgr::INIT);
690
691     //////////////////////////////////////////////////////////////////////
692     // Initialize the 2D cloud subsystem.
693     ////////////////////////////////////////////////////////////////////
694     fgGetBool("/sim/rendering/bump-mapping", false);
695
696     ////////////////////////////////////////////////////////////////////
697     // Initialize the canvas 2d drawing subsystem.
698     ////////////////////////////////////////////////////////////////////
699     simgear::canvas::Canvas::setSystemAdapter(
700       simgear::canvas::SystemAdapterPtr(new canvas::FGCanvasSystemAdapter)
701     );
702     globals->add_subsystem("Canvas", new CanvasMgr, SGSubsystemMgr::DISPLAY);
703     globals->add_subsystem("CanvasGUI", new GUIMgr, SGSubsystemMgr::DISPLAY);
704
705     ////////////////////////////////////////////////////////////////////
706     // Initialise the ATIS Manager
707     // Note that this is old stuff, but is necessary for the
708     // current ATIS implementation. Therefore, leave it in here
709     // until the ATIS system is ported over to make use of the ATIS 
710     // sub system infrastructure.
711     ////////////////////////////////////////////////////////////////////
712
713     globals->add_subsystem("ATIS", new FGATISMgr, SGSubsystemMgr::INIT, 0.4);
714
715     ////////////////////////////////////////////////////////////////////
716    // Initialize the ATC subsystem
717     ////////////////////////////////////////////////////////////////////
718     globals->add_subsystem("ATC", new FGATCManager, SGSubsystemMgr::POST_FDM);
719
720     ////////////////////////////////////////////////////////////////////
721     // Initialize multiplayer subsystem
722     ////////////////////////////////////////////////////////////////////
723
724     globals->add_subsystem("mp", new FGMultiplayMgr, SGSubsystemMgr::POST_FDM);
725
726     ////////////////////////////////////////////////////////////////////
727     // Initialise the AI Model Manager
728     ////////////////////////////////////////////////////////////////////
729     SG_LOG(SG_GENERAL, SG_INFO, "  AI Model Manager");
730     globals->add_subsystem("ai-model", new FGAIManager, SGSubsystemMgr::POST_FDM);
731     globals->add_subsystem("submodel-mgr", new FGSubmodelMgr, SGSubsystemMgr::POST_FDM);
732
733
734     // It's probably a good idea to initialize the top level traffic manager
735     // After the AI and ATC systems have been initialized properly.
736     // AI Traffic manager
737     globals->add_subsystem("traffic-manager", new FGTrafficManager, SGSubsystemMgr::POST_FDM);
738
739     ////////////////////////////////////////////////////////////////////
740     // Add a new 2D panel.
741     ////////////////////////////////////////////////////////////////////
742
743     fgSetArchivable("/sim/panel/visibility");
744     fgSetArchivable("/sim/panel/x-offset");
745     fgSetArchivable("/sim/panel/y-offset");
746     fgSetArchivable("/sim/panel/jitter");
747   
748     ////////////////////////////////////////////////////////////////////
749     // Initialize the controls subsystem.
750     ////////////////////////////////////////////////////////////////////
751     
752     globals->add_subsystem("controls", new FGControls, SGSubsystemMgr::GENERAL);
753
754     ////////////////////////////////////////////////////////////////////
755     // Initialize the input subsystem.
756     ////////////////////////////////////////////////////////////////////
757
758     globals->add_subsystem("input", new FGInput, SGSubsystemMgr::GENERAL);
759
760
761     ////////////////////////////////////////////////////////////////////
762     // Initialize the replay subsystem
763     ////////////////////////////////////////////////////////////////////
764     globals->add_subsystem("replay", new FGReplay);
765     globals->add_subsystem("history", new FGFlightHistory);
766     
767 #ifdef ENABLE_AUDIO_SUPPORT
768     ////////////////////////////////////////////////////////////////////
769     // Initialize the sound-effects subsystem.
770     ////////////////////////////////////////////////////////////////////
771     globals->add_subsystem("voice", new FGVoiceMgr, SGSubsystemMgr::DISPLAY);
772 #endif
773
774 #ifdef ENABLE_IAX
775     ////////////////////////////////////////////////////////////////////
776     // Initialize the FGCom subsystem.
777     ////////////////////////////////////////////////////////////////////
778     globals->add_subsystem("fgcom", new FGCom);
779 #endif
780
781     ////////////////////////////////////////////////////////////////////
782     // Initialize the lighting subsystem.
783     ////////////////////////////////////////////////////////////////////
784
785     // ordering here is important : Nasal (via events), then models, then views
786     if (!duringReset) {
787         globals->add_subsystem("lighting", new FGLight, SGSubsystemMgr::DISPLAY);
788         globals->add_subsystem("events", globals->get_event_mgr(), SGSubsystemMgr::DISPLAY);
789     }
790
791     globals->add_subsystem("aircraft-model", new FGAircraftModel, SGSubsystemMgr::DISPLAY);
792     globals->add_subsystem("model-manager", new FGModelMgr, SGSubsystemMgr::DISPLAY);
793
794     globals->add_subsystem("view-manager", new FGViewMgr, SGSubsystemMgr::DISPLAY);
795
796     globals->add_subsystem("tile-manager", globals->get_tile_mgr(), 
797       SGSubsystemMgr::DISPLAY);
798 }
799
800 void fgPostInitSubsystems()
801 {
802     SGTimeStamp st;
803     st.stamp();
804   
805     ////////////////////////////////////////////////////////////////////////
806     // Initialize the Nasal interpreter.
807     // Do this last, so that the loaded scripts see initialized state
808     ////////////////////////////////////////////////////////////////////////
809     FGNasalSys* nasal = new FGNasalSys();
810     globals->add_subsystem("nasal", nasal, SGSubsystemMgr::INIT);
811     nasal->init();
812     SG_LOG(SG_GENERAL, SG_INFO, "Nasal init took:" << st.elapsedMSec());
813
814     // Ensure IOrules and path validation are working properly by trying to
815     // access a folder/file which should never be accessible.
816     const char* no_access_path =
817 #ifdef _WIN32
818       "Z:"
819 #endif
820       "/do-not-access";
821
822     if( fgValidatePath(no_access_path, true) )
823       SG_LOG
824       (
825         SG_GENERAL,
826         SG_ALERT,
827         "Check your IOrules! (write to '" << no_access_path << "' is allowed)"
828       );
829     if( fgValidatePath(no_access_path, false) )
830       SG_LOG
831       (
832         SG_GENERAL,
833         SG_ALERT,
834         "Check your IOrules! (read from '" << no_access_path << "' is allowed)"
835       );
836   
837     // initialize methods that depend on other subsystems.
838     st.stamp();
839     globals->get_subsystem_mgr()->postinit();
840     SG_LOG(SG_GENERAL, SG_INFO, "Subsystems postinit took:" << st.elapsedMSec());
841   
842     ////////////////////////////////////////////////////////////////////////
843     // End of subsystem initialization.
844     ////////////////////////////////////////////////////////////////////
845
846     fgSetBool("/sim/crashed", false);
847     fgSetBool("/sim/initialized", true);
848
849     SG_LOG( SG_GENERAL, SG_INFO, endl);
850
851                                 // Save the initial state for future
852                                 // reference.
853     globals->saveInitialState();
854 }
855
856 // Reset: this is what the 'reset' command (and hence, GUI) is attached to
857 void fgReInitSubsystems()
858 {
859 #ifdef NEW_RESET
860     fgResetIdleState();
861     return;
862 #endif
863     
864     SGPropertyNode *master_freeze = fgGetNode("/sim/freeze/master");
865
866     SG_LOG( SG_GENERAL, SG_INFO, "fgReInitSubsystems()");
867
868 // setup state to begin re-init
869     bool freeze = master_freeze->getBoolValue();
870     if ( !freeze ) {
871         master_freeze->setBoolValue(true);
872     }
873     
874     fgSetBool("/sim/signals/reinit", true);
875     fgSetBool("/sim/crashed", false);
876
877 // do actual re-init steps
878     globals->get_subsystem("flight")->unbind();
879     
880   // reset control state, before restoring initial state; -set or config files
881   // may specify values for flaps, trim tabs, magnetos, etc
882     globals->get_controls()->reset_all();
883         
884     globals->restoreInitialState();
885
886     // update our position based on current presets
887     // this will mark position as needed finalized which we'll do in the
888     // main-loop
889     flightgear::initPosition();
890     
891     simgear::SGTerraSync* terraSync =
892         static_cast<simgear::SGTerraSync*>(globals->get_subsystem("terrasync"));
893     if (terraSync) {
894         terraSync->reposition();
895     }
896     
897     // Force reupdating the positions of the ai 3d models. They are used for
898     // initializing ground level for the FDM.
899     globals->get_subsystem("ai-model")->reinit();
900
901     // Initialize the FDM
902     globals->get_subsystem("flight")->reinit();
903
904     // reset replay buffers
905     globals->get_subsystem("replay")->reinit();
906     
907     // reload offsets from config defaults
908     globals->get_viewmgr()->reinit();
909
910     // ugly: finalizePosition waits for METAR to arrive for the new airport.
911     // we don't re-init the environment manager here, since historically we did
912     // not, and doing so seems to have other issues. All that's needed is to
913     // schedule METAR fetch immediately, so it's available for finalizePosition.
914     // So we manually extract the METAR-fetching component inside the environment
915     // manager, and re-init that.
916     SGSubsystemGroup* envMgr = static_cast<SGSubsystemGroup*>(globals->get_subsystem("environment"));
917     if (envMgr) {
918       envMgr->get_subsystem("realwx")->reinit();
919     }
920   
921     globals->get_subsystem("time")->reinit();
922
923     // need to bind FDMshell again, since we manually unbound it above...
924     globals->get_subsystem("flight")->bind();
925
926     // need to reset aircraft (systems/instruments) so they can adapt to current environment
927     globals->get_subsystem("systems")->reinit();
928     globals->get_subsystem("instrumentation")->reinit();
929
930     globals->get_subsystem("ATIS")->reinit();
931
932 // setup state to end re-init
933     fgSetBool("/sim/signals/reinit", false);
934     if ( !freeze ) {
935         master_freeze->setBoolValue(false);
936     }
937     fgSetBool("/sim/sceneryloaded",false);
938 }
939
940 void fgStartNewReset()
941 {
942     globals->saveInitialState();
943     
944     fgSetBool("/sim/signals/reinit", true);
945     fgSetBool("/sim/freeze/master", true);
946     
947     SGSubsystemMgr* subsystemManger = globals->get_subsystem_mgr();
948     subsystemManger->shutdown();
949     subsystemManger->unbind();
950     
951     // remove them all (with some exceptions?)
952     for (int g=0; g<SGSubsystemMgr::MAX_GROUPS; ++g) {
953         SGSubsystemGroup* grp = subsystemManger->get_group(static_cast<SGSubsystemMgr::GroupType>(g));
954         const string_list& names(grp->member_names());
955         string_list::const_iterator it;
956         for (it = names.begin(); it != names.end(); ++it) {
957             if ((*it == "time") || (*it == "terrasync") || (*it == "events")
958                 || (*it == "lighting"))
959             {
960                 continue;
961             }
962             
963             try {
964                 subsystemManger->remove(it->c_str());
965             } catch (std::exception& e) {
966                 SG_LOG(SG_GENERAL, SG_INFO, "caught std::exception shutting down:" << *it);
967             } catch (...) {
968                 SG_LOG(SG_GENERAL, SG_INFO, "caught generic exception shutting down:" << *it);
969             }
970             
971             // don't delete here, dropping the ref should be sufficient
972         }
973     } // of top-level groups iteration
974     
975     // order is important here since tile-manager shutdown needs to
976     // access the scenery object
977     globals->set_tile_mgr(NULL);
978     globals->set_scenery(NULL);
979     flightgear::CameraGroup::setDefault(NULL);
980     
981     FGRenderer* render = globals->get_renderer();
982     // don't cancel the pager until after shutdown, since AIModels (and
983     // potentially others) can queue delete requests on the pager.
984     render->getViewer()->getDatabasePager()->cancel();
985     
986     osgDB::Registry::instance()->clearObjectCache();
987     
988     // preserve the event handler; re-creating it would entail fixing the
989     // idle handler
990     osg::ref_ptr<flightgear::FGEventHandler> eventHandler = render->getEventHandler();
991     
992     globals->set_renderer(NULL);
993     globals->set_matlib(NULL);
994     globals->set_chatter_queue(NULL);
995     
996     simgear::clearEffectCache();
997     simgear::SGModelLib::resetPropertyRoot();
998         
999     globals->resetPropertyRoot();
1000     globals->restoreInitialState();
1001     
1002     fgInitConfig(0, NULL, true);
1003     fgInitGeneral(); // all of this?
1004     
1005     fgGetNode("/sim")->removeChild("aircraft-dir");    
1006     fgInitAircraft(true);
1007     flightgear::Options::sharedInstance()->processOptions();
1008     
1009     render = new FGRenderer;
1010     render->setEventHandler(eventHandler);
1011     globals->set_renderer(render);
1012     render->init();
1013     render->setViewer(viewer.get());
1014     viewer->getDatabasePager()->setUpThreads(1, 1);
1015     render->splashinit();
1016     
1017     flightgear::CameraGroup::buildDefaultGroup(viewer.get());
1018
1019     fgOSResetProperties();
1020
1021     
1022 // init some things manually
1023 // which do not follow the regular init pattern
1024     
1025     globals->get_event_mgr()->init();
1026     globals->get_event_mgr()->setRealtimeProperty(fgGetNode("/sim/time/delta-realtime-sec", true));
1027     
1028     globals->set_matlib( new SGMaterialLib );
1029     
1030 // terra-sync needs the property tree root, pass it back in
1031     simgear::SGTerraSync* terra_sync = static_cast<simgear::SGTerraSync*>(subsystemManger->get_subsystem("terrasync"));
1032     terra_sync->setRoot(globals->get_props());
1033
1034     fgSetBool("/sim/signals/reinit", false);
1035     fgSetBool("/sim/freeze/master", false);
1036     fgSetBool("/sim/sceneryloaded",false);
1037 }
1038