src/Sound/soundmanager.cxx

   1 // soundmanager.cxx -- Wraps the SimGear OpenAl sound manager class
   2 //
   3 // Copyright (C) 2001  Curtis L. Olson - http://www.flightgear.org/~curt
   4 //
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License as
   7 // published by the Free Software Foundation; either version 2 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful, but
  11 // WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 //
  19
  20 #include <simgear/sound/soundmgr_openal.hxx>
  21
  22 #include "soundmanager.hxx"
  23 #include "Main/globals.hxx"
  24 #include "Main/fg_props.hxx"
  25
  26 #include <vector>
  27 #include <string>
  28
  29 #ifdef ENABLE_AUDIO_SUPPORT
  30 /**
  31  * Listener class that monitors the sim state.
  32  */
  33 class Listener : public SGPropertyChangeListener
  34 {
  35 public:
  36     Listener(FGSoundManager *wrapper) : _wrapper(wrapper) {}
  37     virtual void valueChanged (SGPropertyNode * node);
  38
  39 private:
  40     FGSoundManager* _wrapper;
  41 };
  42
  43 void Listener::valueChanged(SGPropertyNode * node)
  44 {
  45     _wrapper->activate(node->getBoolValue());
  46 }
  47
  48 FGSoundManager::FGSoundManager()
  49   : _is_initialized(false),
  50     _enabled(false),
  51     _listener(new Listener(this))
  52 {
  53     SGPropertyNode_ptr scenery_loaded = fgGetNode("sim/sceneryloaded", true);
  54     scenery_loaded->addChangeListener(_listener);
  55 }
  56
  57 FGSoundManager::~FGSoundManager()
  58 {
  59 }
  60
  61 void FGSoundManager::init()
  62 {
  63     _sound_working = fgGetNode("/sim/sound/working");
  64     _sound_enabled = fgGetNode("/sim/sound/enabled");
  65     _volume        = fgGetNode("/sim/sound/volume");
  66     _device_name   = fgGetNode("/sim/sound/device-name");
  67
  68     _currentView   = fgGetNode("sim/current-view");
  69     _viewPosLon    = fgGetNode("sim/current-view/viewer-lon-deg");
  70     _viewPosLat    = fgGetNode("sim/current-view/viewer-lat-deg");
  71     _viewPosElev   = fgGetNode("sim/current-view/viewer-elev-ft");
  72
  73     _velocityNorthFPS = fgGetNode("velocities/speed-north-fps", true);
  74     _velocityEastFPS  = fgGetNode("velocities/speed-east-fps", true);
  75     _velocityDownFPS  = fgGetNode("velocities/speed-down-fps", true);
  76
  77     _viewXoffset      = _currentView->getNode("x-offset-m", true);
  78     _viewYoffset      = _currentView->getNode("y-offset-m", true);
  79     _viewZoffset      = _currentView->getNode("z-offset-m", true);
  80
  81     reinit();
  82 }
  83
  84 void FGSoundManager::reinit()
  85 {
  86     _is_initialized = false;
  87
  88     if (_is_initialized && !_sound_working->getBoolValue())
  89     {
  90         // shutdown sound support
  91         stop();
  92         return;
  93     }
  94
  95     if (!_sound_working->getBoolValue())
  96     {
  97         return;
  98     }
  99
 100     update_device_list();
 101
 102     select_device(_device_name->getStringValue());
 103     SGSoundMgr::reinit();
 104     _is_initialized = true;
 105
 106     activate(fgGetBool("sim/sceneryloaded", true));
 107 }
 108
 109 void FGSoundManager::activate(bool State)
 110 {
 111     if (_is_initialized)
 112     {
 113         if (State)
 114         {
 115             SGSoundMgr::activate();
 116         }
 117     }
 118 }
 119
 120 void FGSoundManager::update_device_list()
 121 {
 122     std::vector <const char*>devices = get_available_devices();
 123     for (unsigned int i=0; i<devices.size(); i++) {
 124         SGPropertyNode *p = fgGetNode("/sim/sound/devices/device", i, true);
 125         p->setStringValue(devices[i]);
 126     }
 127     devices.clear();
 128 }
 129
 130 bool FGSoundManager::stationaryView() const
 131 {
 132   // this is an ugly hack to decide if the *viewer* is stationary,
 133   // since we don't model the viewer velocity directly.
 134   return (_viewXoffset->getDoubleValue() == 0.0) &&
 135          (_viewYoffset->getDoubleValue() == 0.0) &&
 136          (_viewZoffset->getDoubleValue() == 0.0);
 137 }
 138
 139 // Update sound manager and propagate property values,
 140 // since the sound manager doesn't read any properties itself.
 141 // Actual sound update is triggered by the subsystem manager.
 142 void FGSoundManager::update(double dt)
 143 {
 144     if (_is_initialized && _sound_working->getBoolValue())
 145     {
 146         bool enabled = _sound_enabled->getBoolValue();
 147         if (enabled != _enabled)
 148         {
 149             if (enabled)
 150                 resume();
 151             else
 152                 suspend();
 153             _enabled = enabled;
 154         }
 155         if (enabled)
 156         {
 157             SGGeod viewPosGeod(SGGeod::fromDegFt(_viewPosLon->getDoubleValue(),
 158                                                  _viewPosLat->getDoubleValue(),
 159                                                  _viewPosElev->getDoubleValue()));
 160             SGVec3d cartPos = SGVec3d::fromGeod(viewPosGeod);
 161
 162             set_position(cartPos, viewPosGeod);
 163
 164             SGQuatd viewOrientation;
 165             for (int i=0; i<4; ++i) {
 166               viewOrientation[i] = _currentView->getChild("raw-orientation", i, true)->getDoubleValue();
 167             }
 168
 169             set_orientation( viewOrientation );
 170
 171             SGVec3d velocity(SGVec3d::zeros());
 172             if (!stationaryView()) {
 173               velocity = SGVec3d(_velocityNorthFPS->getDoubleValue(),
 174                                  _velocityEastFPS->getDoubleValue(),
 175                                  _velocityDownFPS->getDoubleValue() );
 176             }
 177
 178             set_velocity( velocity );
 179
 180             set_volume(_volume->getFloatValue());
 181             SGSoundMgr::update(dt);
 182         }
 183     }
 184 }
 185
 186 #endif // ENABLE_AUDIO_SUPPORT