X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FMain%2Fglobals.cxx;h=a6381569ba53a8dac4351deef707c01767b2bd6c;hb=d127f7709f7ac64fbbc537131bfd02bb29bc1ebe;hp=782a229a88a7498568d031ae670bd5a6192dc489;hpb=35396de6f87e2a8b8d0c21eb1d0908db586799f8;p=flightgear.git diff --git a/src/Main/globals.cxx b/src/Main/globals.cxx index 782a229a8..a6381569b 100644 --- a/src/Main/globals.cxx +++ b/src/Main/globals.cxx @@ -15,8 +15,8 @@ // 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. +// along with this program; if not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // $Id$ @@ -24,40 +24,103 @@ # include #endif -#include +#include +#include + #include #include +#include #include #include -#include #include #include #include +#include +#include +#include +#include #include #include -#include -#include +#include #include -#include -#include -#include -#include +#include +#include #include -#include #include #include #include -#include +#include +#include #include "globals.hxx" -#include "renderer.hxx" -#include "viewmgr.hxx" +#include "locale.hxx" #include "fg_props.hxx" #include "fg_io.hxx" - +class AircraftResourceProvider : public simgear::ResourceProvider +{ +public: + AircraftResourceProvider() : + simgear::ResourceProvider(simgear::ResourceManager::PRIORITY_HIGH) + { + } + + virtual SGPath resolve(const std::string& aResource, SGPath&) const + { + string_list pieces(sgPathBranchSplit(aResource)); + if ((pieces.size() < 3) || (pieces.front() != "Aircraft")) { + return SGPath(); // not an Aircraft path + } + + // test against the aircraft-dir property + const char* aircraftDir = fgGetString("/sim/aircraft-dir"); + string_list aircraftDirPieces(sgPathBranchSplit(aircraftDir)); + if (!aircraftDirPieces.empty() && (aircraftDirPieces.back() == pieces[1])) { + // current aircraft-dir matches resource aircraft + SGPath r(aircraftDir); + for (unsigned int i=2; iget_aircraft_paths()); + string_list::const_iterator it = dirs.begin(); + for (; it != dirs.end(); ++it) { + SGPath p(*it, res); + if (p.exists()) { + return p; + } + } // of aircraft path iteration + + return SGPath(); // not found + } +}; + +class CurrentAircraftDirProvider : public simgear::ResourceProvider +{ +public: + CurrentAircraftDirProvider() : + simgear::ResourceProvider(simgear::ResourceManager::PRIORITY_HIGH) + { + } + + virtual SGPath resolve(const std::string& aResource, SGPath&) const + { + const char* aircraftDir = fgGetString("/sim/aircraft-dir"); + SGPath p(aircraftDir); + p.append(aResource); + return p.exists() ? p : SGPath(); + } +}; + //////////////////////////////////////////////////////////////////////// // Implementation of FGGlobals. //////////////////////////////////////////////////////////////////////// @@ -68,109 +131,106 @@ FGGlobals *globals; // Constructor FGGlobals::FGGlobals() : + props( new SGPropertyNode ), + initial_state( NULL ), + locale( new FGLocale(props) ), renderer( new FGRenderer ), subsystem_mgr( new SGSubsystemMgr ), event_mgr( new SGEventMgr ), sim_time_sec( 0.0 ), fg_root( "" ), - warp( 0 ), - warp_delta( 0 ), + fg_home( "" ), time_params( NULL ), ephem( NULL ), - mag( NULL ), matlib( NULL ), route_mgr( NULL ), - current_panel( NULL ), - soundmgr( NULL ), - ATC_mgr( NULL ), - AI_mgr( NULL ), + ATIS_mgr( NULL ), controls( NULL ), viewmgr( NULL ), - props( new SGPropertyNode ), - initial_state( NULL ), - locale( NULL ), commands( SGCommandMgr::instance() ), - acmodel( NULL ), - model_mgr( NULL ), channel_options_list( NULL ), initial_waypoints( NULL ), scenery( NULL ), tile_mgr( NULL ), - io( new FGIO ), fontcache ( new FGFontCache ), - navlist( NULL ), - loclist( NULL ), - gslist( NULL ), - dmelist( NULL ), - tacanlist( NULL ), - carrierlist( NULL ), channellist( NULL ), - airwaynet( NULL ), - multiplayer_mgr( NULL ) + haveUserSettings(false) { + simgear::ResourceManager::instance()->addProvider(new AircraftResourceProvider); + simgear::ResourceManager::instance()->addProvider(new CurrentAircraftDirProvider); + simgear::PropertyObjectBase::setDefaultRoot(props); + + positionLon = props->getNode("position/longitude-deg", true); + positionLat = props->getNode("position/latitude-deg", true); + positionAlt = props->getNode("position/altitude-ft", true); + + viewLon = props->getNode("sim/current-view/viewer-lon-deg", true); + viewLat = props->getNode("sim/current-view/viewer-lat-deg", true); + viewAlt = props->getNode("sim/current-view/viewer-elev-ft", true); + + orientPitch = props->getNode("orientation/pitch-deg", true); + orientHeading = props->getNode("orientation/heading-deg", true); + orientRoll = props->getNode("orientation/roll-deg", true); } - // Destructor FGGlobals::~FGGlobals() { - delete renderer; -// The AIModels manager performs a number of actions upon + // save user settings (unless already saved) + saveUserSettings(); + + // The AIModels manager performs a number of actions upon // Shutdown that implicitly assume that other subsystems // are still operational (Due to the dynamic allocation and // deallocation of AIModel objects. To ensure we can safely // shut down all subsystems, make sure we take down the // AIModels system first. - subsystem_mgr->get_group(SGSubsystemMgr::GENERAL)->remove_subsystem("ai_model"); + SGSubsystem* ai = subsystem_mgr->remove("ai-model"); + if (ai) { + ai->unbind(); + delete ai; + } + SGSubsystem* sound = subsystem_mgr->remove("sound"); + + subsystem_mgr->shutdown(); + subsystem_mgr->unbind(); delete subsystem_mgr; - delete event_mgr; + + delete renderer; + renderer = NULL; + delete time_params; - delete ephem; - delete mag; delete matlib; delete route_mgr; - delete current_panel; - delete soundmgr; - delete ATC_mgr; - delete AI_mgr; - delete controls; - delete viewmgr; + delete ATIS_mgr; -// delete commands; - delete acmodel; - delete model_mgr; delete channel_options_list; delete initial_waypoints; - delete tile_mgr; delete scenery; - delete io; delete fontcache; - delete navlist; - delete loclist; - delete gslist; - delete dmelist; - delete tacanlist; - delete carrierlist; delete channellist; - delete airwaynet; - delete multiplayer_mgr; -} + delete sound; + delete locale; + locale = NULL; +} // set the fg_root path -void FGGlobals::set_fg_root (const string &root) { - fg_root = root; +void FGGlobals::set_fg_root (const std::string &root) { + SGPath tmp(root); + fg_root = tmp.realpath(); // append /data to root if it exists - SGPath tmp( fg_root ); tmp.append( "data" ); tmp.append( "version" ); - if ( ulFileExists( tmp.c_str() ) ) { + if ( tmp.exists() ) { + fgGetNode("BAD_FG_ROOT", true)->setStringValue(fg_root); fg_root += "/data"; - SG_LOG(SG_GENERAL, SG_WARN, "Warning: changing bad FG_ROOT/--fg-root to '" - << fg_root << '\''); + fgGetNode("GOOD_FG_ROOT", true)->setStringValue(fg_root); + SG_LOG(SG_GENERAL, SG_ALERT, "***\n***\n*** Warning: changing bad FG_ROOT/--fg-root to '" + << fg_root << "'\n***\n***"); } // remove /sim/fg-root before writing to prevent hijacking @@ -179,52 +239,163 @@ void FGGlobals::set_fg_root (const string &root) { n = n->getChild("fg-root", 0, true); n->setStringValue(fg_root.c_str()); n->setAttribute(SGPropertyNode::WRITE, false); + + simgear::ResourceManager::instance()->addBasePath(fg_root, + simgear::ResourceManager::PRIORITY_DEFAULT); } -void FGGlobals::set_fg_scenery (const string &scenery) { - SGPath s; - if (scenery.empty()) { - s.set( fg_root ); - s.append( "Scenery" ); - } else - s.set( scenery ); - - string_list path_list = sgPathSplit( s.str() ); - fg_scenery.clear(); - - for (unsigned i = 0; i < path_list.size(); i++) { - - ulDir *d = ulOpenDir( path_list[i].c_str() ); - if (d == NULL) - continue; - ulCloseDir( d ); - - SGPath pt( path_list[i] ), po( path_list[i] ); - pt.append("Terrain"); - po.append("Objects"); - - ulDir *td = ulOpenDir( pt.c_str() ); - ulDir *od = ulOpenDir( po.c_str() ); - - if (td == NULL && od == NULL) - fg_scenery.push_back( path_list[i] ); - else { - if (td != NULL) { - fg_scenery.push_back( pt.str() ); - ulCloseDir( td ); - } - if (od != NULL) { - fg_scenery.push_back( po.str() ); - ulCloseDir( od ); - } +// set the fg_home path +void FGGlobals::set_fg_home (const std::string &home) { + SGPath tmp(home); + fg_home = tmp.realpath(); +} + +PathList FGGlobals::get_data_paths() const +{ + PathList r(additional_data_paths); + r.push_back(SGPath(fg_root)); + return r; +} + +PathList FGGlobals::get_data_paths(const std::string& suffix) const +{ + PathList r; + BOOST_FOREACH(SGPath p, get_data_paths()) { + p.append(suffix); + if (p.exists()) { + r.push_back(p); + } + } + + return r; +} + +void FGGlobals::append_data_path(const SGPath& path) +{ + if (!path.exists()) { + SG_LOG(SG_GENERAL, SG_WARN, "adding non-existant data path:" << path); + } + + additional_data_paths.push_back(path); +} + +SGPath FGGlobals::find_data_dir(const std::string& pathSuffix) const +{ + BOOST_FOREACH(SGPath p, additional_data_paths) { + p.append(pathSuffix); + if (p.exists()) { + return p; + } + } + + SGPath rootPath(fg_root); + rootPath.append(pathSuffix); + if (rootPath.exists()) { + return rootPath; + } + + SG_LOG(SG_GENERAL, SG_WARN, "dir not found in any data path:" << pathSuffix); + return SGPath(); +} + +void FGGlobals::append_fg_scenery (const std::string &paths) +{ +// fg_scenery.clear(); + SGPropertyNode* sim = fgGetNode("/sim", true); + + // find first unused fg-scenery property in /sim + int propIndex = 0; + while (sim->getChild("fg-scenery", propIndex) != NULL) { + ++propIndex; + } + + BOOST_FOREACH(const SGPath& path, sgPathSplit( paths )) { + SGPath abspath(path.realpath()); + if (!abspath.exists()) { + SG_LOG(SG_GENERAL, SG_WARN, "scenery path not found:" << abspath.str()); + continue; + } + + // check for duplicates + string_list::const_iterator ex = std::find(fg_scenery.begin(), fg_scenery.end(), abspath.str()); + if (ex != fg_scenery.end()) { + SG_LOG(SG_GENERAL, SG_INFO, "skipping duplicate add of scenery path:" << abspath.str()); + continue; + } + + simgear::Dir dir(abspath); + SGPath terrainDir(dir.file("Terrain")); + SGPath objectsDir(dir.file("Objects")); + + // this code used to add *either* the base dir, OR add the + // Terrain and Objects subdirs, but the conditional logic was commented + // out, such that all three dirs are added. Unfortunately there's + // no information as to why the change was made. + fg_scenery.push_back(abspath.str()); + + if (terrainDir.exists()) { + fg_scenery.push_back(terrainDir.str()); + } + + if (objectsDir.exists()) { + fg_scenery.push_back(objectsDir.str()); } + // insert a marker for FGTileEntry::load(), so that // FG_SCENERY=A:B becomes list ["A/Terrain", "A/Objects", "", // "B/Terrain", "B/Objects", ""] fg_scenery.push_back(""); - } + + // make scenery dirs available to Nasal + SGPropertyNode* n = sim->getChild("fg-scenery", propIndex++, true); + n->setStringValue(abspath.str()); + n->setAttribute(SGPropertyNode::WRITE, false); + } // 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; + } + std::string abspath = dirPath.realpath(); + + unsigned int index = fg_aircraft_dirs.size(); + fg_aircraft_dirs.push_back(abspath); + +// make aircraft dirs available to Nasal + SGPropertyNode* sim = fgGetNode("/sim", true); + sim->removeChild("fg-aircraft", index, false); + SGPropertyNode* n = sim->getChild("fg-aircraft", index, true); + n->setStringValue(abspath); + n->setAttribute(SGPropertyNode::WRITE, false); +} + +void FGGlobals::append_aircraft_paths(const std::string& path) +{ + string_list paths = sgPathSplit(path); + for (unsigned int p = 0; pfindPath(branch); +} + +SGPath FGGlobals::resolve_maybe_aircraft_path(const std::string& branch) const +{ + return simgear::ResourceManager::instance()->findPath(branch); +} + +SGPath FGGlobals::resolve_resource_path(const std::string& branch) const +{ + return simgear::ResourceManager::instance() + ->findPath(branch, SGPath(fgGetString("/sim/aircraft-dir"))); +} FGRenderer * FGGlobals::get_renderer () const @@ -253,6 +424,14 @@ FGGlobals::add_subsystem (const char * name, subsystem_mgr->add(name, subsystem, type, min_time_sec); } +SGSoundMgr * +FGGlobals::get_soundmgr () const +{ + if (subsystem_mgr) + return (SGSoundMgr*) subsystem_mgr->get_subsystem("sound"); + + return NULL; +} SGEventMgr * FGGlobals::get_event_mgr () const @@ -260,6 +439,40 @@ FGGlobals::get_event_mgr () const return event_mgr; } +SGGeod +FGGlobals::get_aircraft_position() const +{ + return SGGeod::fromDegFt(positionLon->getDoubleValue(), + positionLat->getDoubleValue(), + positionAlt->getDoubleValue()); +} + +SGVec3d +FGGlobals::get_aircraft_position_cart() const +{ + return SGVec3d::fromGeod(get_aircraft_position()); +} + +void FGGlobals::get_aircraft_orientation(double& heading, double& pitch, double& roll) +{ + heading = orientHeading->getDoubleValue(); + pitch = orientPitch->getDoubleValue(); + roll = orientRoll->getDoubleValue(); +} + +SGGeod +FGGlobals::get_view_position() const +{ + return SGGeod::fromDegFt(viewLon->getDoubleValue(), + viewLat->getDoubleValue(), + viewAlt->getDoubleValue()); +} + +SGVec3d +FGGlobals::get_view_position_cart() const +{ + return SGVec3d::fromGeod(get_view_position()); +} // Save the current state as the initial state. void @@ -267,10 +480,36 @@ FGGlobals::saveInitialState () { initial_state = new SGPropertyNode(); - if (!copyProperties(props, initial_state)) + // copy properties which are READ/WRITEable - but not USERARCHIVEd or PRESERVEd + int checked = SGPropertyNode::READ+SGPropertyNode::WRITE+ + SGPropertyNode::USERARCHIVE+SGPropertyNode::PRESERVE; + int expected = SGPropertyNode::READ+SGPropertyNode::WRITE; + if (!copyProperties(props, initial_state, expected, checked)) SG_LOG(SG_GENERAL, SG_ALERT, "Error saving initial state"); + + // delete various properties from the initial state, since we want to + // preserve their values even if doing a restore + // => Properties should now use the PRESERVE flag to protect their values + // on sim-reset. Remove some specific properties for backward compatibility. + SGPropertyNode* sim = initial_state->getChild("sim"); + SGPropertyNode* cameraGroupNode = sim->getNode("rendering/camera-group"); + if (cameraGroupNode) { + cameraGroupNode->removeChild("camera"); + cameraGroupNode->removeChild("gui"); + } } +static std::string autosaveName() +{ + std::ostringstream os; + string_list versionParts = simgear::strutils::split(VERSION, "."); + if (versionParts.size() < 2) { + return "autosave.xml"; + } + + os << "autosave_" << versionParts[0] << "_" << versionParts[1] << ".xml"; + return os.str(); +} // Restore the saved initial state, if any void @@ -281,29 +520,64 @@ FGGlobals::restoreInitialState () "No initial state available to restore!!!"); return; } - - SGPropertyNode *currentPresets = new SGPropertyNode; - SGPropertyNode *targetNode = fgGetNode( "/sim/presets" ); - - // stash the /sim/presets tree - if ( !copyProperties(targetNode, currentPresets) ) { - SG_LOG( SG_GENERAL, SG_ALERT, "Failed to save /sim/presets subtree" ); - } - - if ( copyProperties(initial_state, props) ) { + // copy properties which are READ/WRITEable - but not USERARCHIVEd or PRESERVEd + int checked = SGPropertyNode::READ+SGPropertyNode::WRITE+ + SGPropertyNode::USERARCHIVE+SGPropertyNode::PRESERVE; + int expected = SGPropertyNode::READ+SGPropertyNode::WRITE; + if ( copyProperties(initial_state, props, expected, checked)) { SG_LOG( SG_GENERAL, SG_INFO, "Initial state restored successfully" ); } else { SG_LOG( SG_GENERAL, SG_INFO, "Some errors restoring initial state (read-only props?)" ); } - // recover the /sim/presets tree - if ( !copyProperties(currentPresets, targetNode) ) { - SG_LOG( SG_GENERAL, SG_ALERT, - "Failed to restore /sim/presets subtree" ); +} + +// Load user settings from autosave.xml +void +FGGlobals::loadUserSettings(const SGPath& dataPath) +{ + // remember that we have (tried) to load any existing autsave.xml + haveUserSettings = true; + + SGPath autosaveFile = simgear::Dir(dataPath).file(autosaveName()); + SGPropertyNode autosave; + if (autosaveFile.exists()) { + SG_LOG(SG_INPUT, SG_INFO, "Reading user settings from " << autosaveFile.str()); + try { + readProperties(autosaveFile.str(), &autosave, SGPropertyNode::USERARCHIVE); + } catch (sg_exception& e) { + SG_LOG(SG_INPUT, SG_WARN, "failed to read user settings:" << e.getMessage() + << "(from " << e.getOrigin() << ")"); + } } + copyProperties(&autosave, globals->get_props()); +} + +// Save user settings in autosave.xml +void +FGGlobals::saveUserSettings() +{ + // only save settings when we have (tried) to load the previous + // settings (otherwise user data was lost) + if (!haveUserSettings) + return; - delete currentPresets; + if (fgGetBool("/sim/startup/save-on-exit")) { + // don't save settings more than once on shutdown + haveUserSettings = false; + + SGPath autosaveFile(globals->get_fg_home()); + autosaveFile.append(autosaveName()); + autosaveFile.create_dir( 0700 ); + SG_LOG(SG_IO, SG_INFO, "Saving user settings to " << autosaveFile.str()); + try { + writeProperties(autosaveFile.str(), globals->get_props(), false, SGPropertyNode::USERARCHIVE); + } catch (const sg_exception &e) { + guiErrorMessage("Error writing autosave:", e); + } + SG_LOG(SG_INPUT, SG_DEBUG, "Finished Saving user settings"); + } } FGViewer * @@ -312,4 +586,24 @@ FGGlobals::get_current_view () const return viewmgr->get_current_view(); } +long int FGGlobals::get_warp() const +{ + return fgGetInt("/sim/time/warp"); +} + +void FGGlobals::set_warp( long int w ) +{ + fgSetInt("/sim/time/warp", w); +} + +long int FGGlobals::get_warp_delta() const +{ + return fgGetInt("/sim/time/warp-delta"); +} + +void FGGlobals::set_warp_delta( long int d ) +{ + fgSetInt("/sim/time/warp-delta", d); +} + // end of globals.cxx