Flight-history men usage cap.

[flightgear.git] / src / Sound / fg_fx.cxx

diff --git a/src/Sound/fg_fx.cxx b/src/Sound/fg_fx.cxx
index 831375454bf1d39ced649ae201995ddb0219d3cc..d3a050426b62c903b35a230c72520b2f493ebbc3 100644 (file)
--- a/src/Sound/fg_fx.cxx
+++ b/src/Sound/fg_fx.cxx
@@ -32,27 +32,57 @@
 #include "fg_fx.hxx"
 
 #include <Main/fg_props.hxx>
+#include <Main/globals.hxx>
 
 #include <simgear/props/props.hxx>
+#include <simgear/props/props_io.hxx>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/sound/soundmgr_openal.hxx>
 #include <simgear/sound/xmlsound.hxx>
 
-FGFX::FGFX ( SGSoundMgr *smgr, const string &refname ) :
-    last_enabled( true ),
-    last_volume( 0.0 ),
-    _enabled( fgGetNode("/sim/sound/effects/enabled", true) ),
-    _volume( fgGetNode("/sim/sound/effects/volume", true) )
+FGFX::FGFX ( const std::string &refname, SGPropertyNode *props ) :
+    _props( props )
 {
-    SGSampleGroup::_smgr = smgr;
-    SGSampleGroup::_refname = refname;
-    SGSampleGroup::_smgr->add(this, refname);
-    _avionics = _smgr->find("avionics", true);
-    _avionics->tie_to_listener();
-    _enabled->setBoolValue(true);
-    _volume->setFloatValue(1.0);
+    if (!props) {
+        _is_aimodel = false;
+        _props = globals->get_props();
+        _enabled = fgGetNode("/sim/sound/effects/enabled", true);
+        _volume = fgGetNode("/sim/sound/effects/volume", true);
+    } else {
+        _is_aimodel = true;
+        _enabled = _props->getNode("/sim/sound/aimodels/enabled", true);
+        _enabled->setBoolValue(fgGetBool("/sim/sound/effects/enabled"));
+         _volume = _props->getNode("/sim/sound/aimodels/volume", true);
+        _volume->setFloatValue(fgGetFloat("/sim/sound/effects/volume"));
+    }
+
+    _avionics_enabled = _props->getNode("sim/sound/avionics/enabled", true);
+    _avionics_volume = _props->getNode("sim/sound/avionics/volume", true);
+    _avionics_ext = _props->getNode("sim/sound/avionics/external-view", true);
+    _internal = _props->getNode("sim/current-view/internal", true);
+
+    _smgr = globals->get_soundmgr();
+    if (!_smgr) {
+      return;
+    }
+  
+    _refname = refname;
+    _smgr->add(this, refname);
+
+    if (!_is_aimodel)
+    {
+        _avionics = _smgr->find("avionics", true);
+        _avionics->tie_to_listener();
+    }
 }
 
+void FGFX::unbind()
+{
+    if (_smgr)
+    {
+        _smgr->remove(_refname);
+    }
+}
 
 FGFX::~FGFX ()
 {
@@ -66,24 +96,33 @@ FGFX::~FGFX ()
 void
 FGFX::init()
 {
-    SGPropertyNode *node = fgGetNode("/sim/sound", true);
+    if (!_smgr) {
+        return;
+    }
+  
+    SGPropertyNode *node = _props->getNode("sim/sound", true);
 
-    string path_str = node->getStringValue("path");
-    SGPath path( globals->get_fg_root() );
+    std::string path_str = node->getStringValue("path");
     if (path_str.empty()) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "No path in /sim/sound/path");
+        SG_LOG(SG_SOUND, SG_ALERT, "No path in sim/sound/path");
         return;
     }
-
-    path.append(path_str.c_str());
-    SG_LOG(SG_GENERAL, SG_INFO, "Reading sound " << node->getName()
+    
+    SGPath path = globals->resolve_aircraft_path(path_str);
+    if (path.isNull())
+    {
+        SG_LOG(SG_SOUND, SG_ALERT,
+               "File not found: '" << path_str);
+        return;
+    }
+    SG_LOG(SG_SOUND, SG_INFO, "Reading sound " << node->getName()
            << " from " << path.str());
 
     SGPropertyNode root;
     try {
         readProperties(path.str(), &root);
     } catch (const sg_exception &) {
-        SG_LOG(SG_GENERAL, SG_ALERT,
+        SG_LOG(SG_SOUND, SG_ALERT,
                "Error reading file '" << path.str() << '\'');
         return;
     }
@@ -91,16 +130,15 @@ FGFX::init()
     node = root.getNode("fx");
     if(node) {
         for (int i = 0; i < node->nChildren(); ++i) {
-            SGXmlSound *sound = new SGXmlSound();
+            SGXmlSound *soundfx = new SGXmlSound();
   
             try {
-                sound->init(globals->get_props(), node->getChild(i), this,
-                            _avionics, globals->get_fg_root());
-  
-                _sound.push_back(sound);
+                soundfx->init( _props, node->getChild(i), this, _avionics,
+                               path.dir() );
+                _sound.push_back( soundfx );
             } catch ( sg_exception &e ) {
-                SG_LOG(SG_GENERAL, SG_ALERT, e.getFormattedMessage());
-                delete sound;
+                SG_LOG(SG_SOUND, SG_ALERT, e.getFormattedMessage());
+                delete soundfx;
             }
         }
     }
@@ -110,31 +148,36 @@ FGFX::init()
 void
 FGFX::reinit()
 {
+    for ( unsigned int i = 0; i < _sound.size(); i++ ) {
+        delete _sound[i];
+    }
     _sound.clear();
     init();
-};
+}
 
 
 void
 FGFX::update (double dt)
 {
-    bool new_enabled = _enabled->getBoolValue();
-    if ( new_enabled != last_enabled ) {
-        if ( new_enabled ) {
-            resume();
-        } else {
-            suspend();
-        }
-        last_enabled = new_enabled;
+    if (!_smgr) {
+        return;
     }
-
-    if ( new_enabled ) {
-        double volume = _volume->getDoubleValue();
-        if ( volume != last_volume ) {
-            set_volume( volume );        
-            last_volume = volume;
+      
+    if ( _enabled->getBoolValue() ) {
+        if ( _avionics_enabled->getBoolValue())
+        {
+            if (_avionics_ext->getBoolValue() || _internal->getBoolValue()) {
+                // avionics sound is enabled
+                _avionics->resume(); // no-op if already in resumed state
+                _avionics->set_volume( _avionics_volume->getFloatValue() );
+            }
+            else
+                _avionics->suspend();
         }
 
+        set_volume( _volume->getDoubleValue() );
+        resume();
+
         // update sound effects if not paused
         for ( unsigned int i = 0; i < _sound.size(); i++ ) {
             _sound[i]->update(dt);
@@ -142,6 +185,8 @@ FGFX::update (double dt)
 
         SGSampleGroup::update(dt);
     }
+    else
+        suspend();
 }
 
 // end of fg_fx.cxx