nevrax.org : docs

00001 
00007 /* Copyright, 2001 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "stdsound.h"
00027 
00028 #include "background_source.h"
00029 
00030 using namespace std;
00031 using namespace NLMISC;
00032 
00033 namespace NLSOUND 
00034 {
00035 
00037 const TTime             ENV_CHK_INTERVAL = 3000;        
00038 
00039 
00040 CBackgroundSource::CBackgroundSource(CBackgroundSound *backgroundSource, bool spawn, TSpawnEndCallback cb, void *cbUserParam)
00041 :       CSourceCommon(backgroundSource, spawn, cb, cbUserParam)
00042 {
00043         _BackgroundSound = backgroundSource;
00044 }
00045 
00046 CBackgroundSource::~CBackgroundSource()
00047 {
00048         if (_Playing)
00049                 stop();
00050 }
00051 
00052 void CBackgroundSource::setSound( TSoundId id, CSoundContext *context)
00053 {
00054         nlassert(false);
00055 }
00056 
00057 TSoundId CBackgroundSource::getSound()
00058 {
00059         return NULL;
00060 }
00061         
00062 void CBackgroundSource::setGain( float gain )
00063 {
00064         CSourceCommon::setGain(gain);
00065 
00066         std::vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00067         for (; first != last; ++first)
00068         {
00069                 if (first->Source != 0)
00070                         first->Source->setRelativeGain(_Gain);
00071         }
00072 }
00073 void CBackgroundSource::setRelativeGain( float gain )
00074 {
00075         CSourceCommon::setRelativeGain(gain);
00076 
00077         std::vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00078         for (; first != last; ++first)
00079         {
00080                 if (first->Source != 0)
00081                         first->Source->setRelativeGain(_Gain);
00082         }
00083 }
00084 
00085 void CBackgroundSource::setPos( const NLMISC::CVector& pos )
00086 {
00087         CSourceCommon::setPos(pos);
00088 
00089         std::vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00090         for (; first != last; ++first)
00091         {
00092                 if (first->Source != 0)
00093                         first->Source->setPos(pos);
00094         }
00095 }
00096 
00097 void CBackgroundSource::setVelocity( const NLMISC::CVector& vel )
00098 {
00099         CSourceCommon::setVelocity(vel);
00100 
00101         std::vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00102         for (; first != last; ++first)
00103         {
00104                 if (first->Source != 0)
00105                         first->Source->setVelocity(vel);
00106         }
00107 }
00108 void CBackgroundSource::setDirection( const NLMISC::CVector& dir )
00109 {
00110         CSourceCommon::setDirection(dir);
00111 
00112         std::vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00113         for (; first != last; ++first)
00114         {
00115                 if (first->Source != 0)
00116                         first->Source->setDirection(dir);
00117         }
00118 }
00119 
00120 
00121 
00122 void CBackgroundSource::play()
00123 {
00124         if (_Playing)
00125                 stop();
00126 
00127         CAudioMixerUser *mixer = CAudioMixerUser::instance();
00128                 
00129         const vector<CBackgroundSound::TSoundInfo> &sounds = _BackgroundSound->getSounds();
00130         vector<CBackgroundSound::TSoundInfo>::const_iterator first(sounds.begin()), last(sounds.end());
00131 
00132         for (; first != last; ++first)
00133         {
00134                 TSubSource subSource;
00135                 subSource.Source = mixer->createSource(first->SoundName, false);
00136                 subSource.Filter = first->Filter;
00137                 subSource.FadeStart = 0;
00138                 subSource.FilterFadeIn = first->FilterFadeIn;
00139                 subSource.FilterFadeOut = first->FilterFadeOut;
00140 
00141                 if (subSource.Source && checkFilter(subSource.Filter))
00142                 {
00143                         subSource.Status = SUB_STATUS_PLAY;
00144                         subSource.Source->setRelativeGain(_Gain);
00145                         subSource.Source->setPos(_Position);
00146                         subSource.Source->play();
00147                 }
00148                 else
00149                 {
00150                         subSource.Status = SUB_STATUS_STOP;
00151                 }
00152 
00153                 _Sources.push_back(subSource);
00154         }
00155 
00156         _LastCheck = NLMISC::CTime::getLocalTime();
00157 
00158         // Set an event for next env checking.
00159         mixer->addEvent(this, _LastCheck+ENV_CHK_INTERVAL);
00160 
00161         CSourceCommon::play();
00162 }
00163 
00164 void CBackgroundSource::stop()
00165 {
00166         if (_Playing)
00167         {
00168                 CAudioMixerUser *mixer = CAudioMixerUser::instance();
00169                 mixer->unregisterUpdate(this);
00170                 mixer->removeEvents(this);
00171         
00172                 while (!_Sources.empty())
00173                 {
00174                         TSubSource &subSource = _Sources.back();
00175                         if (subSource.Source != NULL)
00176                         {
00177 //                              subSource.Source->stop();
00178                                 //mixer->removeSource(subSource.Source);
00179                                 delete subSource.Source;
00180 
00181                         }
00182                         _Sources.pop_back();
00183                 }
00184         }
00185 
00186         CSourceCommon::stop();
00187 }
00188 
00189 void CBackgroundSource::onUpdate()
00190 {
00191         // this is called for fade in/out.
00192         CAudioMixerUser *mixer = CAudioMixerUser::instance();
00193         bool doFade = false;
00194         TTime now = NLMISC::CTime::getLocalTime();
00195         float gain;
00196 
00197         vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00198         for (; first != last; ++first)
00199         {
00200                 if (first->Source != NULL)
00201                 {
00202                         if (first->Status == SUB_STATUS_FADEIN)
00203                         {
00204                                 if (first->FilterFadeIn > 0)
00205                                         gain = (now - first->FadeStart) / float(first->FilterFadeIn);
00206                                 else
00207                                         gain = 1.0f;
00208 
00209                                 if (gain < 1.0f)
00210                                 {
00211                                         first->Source->setRelativeGain(gain);
00212                                         doFade = true;
00213                                 }
00214                                 else
00215                                 {
00216                                         // fade end
00217                                         first->Source->setRelativeGain(1.0f * _Gain);
00218                                         first->Status = SUB_STATUS_PLAY;
00219                                 }
00220                         }
00221                         else if (first->Status == SUB_STATUS_FADEOUT)
00222                         {
00223                                 if (first->FilterFadeOut > 0)
00224                                         gain = 1.0f - (now - first->FadeStart) / float(first->FilterFadeOut);
00225                                 else
00226                                         gain = 0.0f;
00227                                 if (gain > 0.0f)
00228                                 {
00229                                         first->Source->setRelativeGain(gain * _Gain);
00230                                         doFade = true;
00231                                 }
00232                                 else
00233                                 {
00234                                         first->Source->stop();
00235                                         first->Status = SUB_STATUS_STOP;
00236                                 }
00237                         }
00238                 }
00239         }
00240 
00241         // any fade to update ?
00242         if (!doFade)
00243                 mixer->unregisterUpdate(this);
00244 }
00245 
00246 void CBackgroundSource::onEvent()
00247 {
00248         // check all sounds and test for start or stop.
00249         CAudioMixerUser *mixer = CAudioMixerUser::instance();
00250 
00251         bool doFade = false;
00252         TTime now = NLMISC::CTime::getLocalTime();
00253 
00254         vector<TSubSource>::iterator first(_Sources.begin()), last(_Sources.end());
00255         for (; first != last; ++first)
00256         {
00257                 if (first->Source != NULL)
00258                 {
00259                         if (checkFilter(first->Filter))
00260                         {
00261                                 // source ok
00262                                 if (first->Status == SUB_STATUS_STOP)
00263                                 {
00264                                         first->Status = SUB_STATUS_FADEIN;
00265                                         first->Source->setRelativeGain(0.0f);
00266                                         first->Source->setPos(_Position);
00267                                         first->Source->play();
00268                                         first->FadeStart = now;
00269                                         doFade = true;
00270                                 }
00271                                 else if (first->Status == SUB_STATUS_FADEOUT)
00272                                 {
00273                                         first->Status = SUB_STATUS_FADEIN;
00274                                         // Replace fade start date to smoosly reverse the fade.
00275                                         first->FadeStart = now - (first->FadeStart - first->FilterFadeOut);
00276                                         doFade = true;
00277                                 }
00278                         }
00279                         else
00280                         {
00281                                 // source masked.
00282                                 if (first->Status == SUB_STATUS_PLAY)
00283                                 {
00284                                         first->Status = SUB_STATUS_FADEOUT;
00285                                         first->FadeStart = now;
00286                                         doFade = true;
00287                                 }
00288                                 else if (first->Status == SUB_STATUS_FADEIN)
00289                                 {
00290                                         first->Status = SUB_STATUS_FADEOUT;
00291                                         // Replace fade start date to smoosly reverse the fade.
00292                                         first->FadeStart = now - (first->FadeStart - first->FilterFadeIn);
00293                                         doFade = true;
00294                                 }
00295                         }
00296                 }
00297         }
00298 
00299         if (doFade)
00300         {
00301                 // register for fade in/out
00302                 mixer->registerUpdate(this);
00303         }
00304 
00305         _LastCheck = NLMISC::CTime::getLocalTime();
00306 
00307         // set the next event.
00308         mixer->addEvent(this, _LastCheck + ENV_CHK_INTERVAL);
00309 }
00310 
00311 
00312 bool CBackgroundSource::checkFilter(const UAudioMixer::TBackgroundFlags &filter)
00313 {
00314         // Get the current environnement from the bakgound sound manager.
00315         const UAudioMixer::TBackgroundFlags &bg = CAudioMixerUser::instance()->getBackgroundSoundManager()->getBackgroundFlags();
00316 
00317         bool ok = true;
00318 
00319         for (uint i=0; i<16; ++i)
00320                 ok &= filter.Flags[i] || !bg.Flags[i];
00321 
00322         return ok;
00323 }
00324 
00325 
00326 } // NLSOUND
background_source.cpp
