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 "complex_source.h"
+00029 #include "complex_sound.h"
+00030 
+00031 using namespace std;
+00032 using namespace NLMISC;
+00033 
+00034 namespace NLSOUND 
+00035 {
+00036 
+00037 CComplexSource::CComplexSource  (CComplexSound *soundPattern, bool spawn, TSpawnEndCallback cb, void *cbUserParam)
+00038 :       CSourceCommon(soundPattern, spawn, cb, cbUserParam),
+00039         _Source1(NULL),
+00040         _Source2(NULL)
+00041 {
+00042         nlassert(soundPattern->getSoundType() == CSound::SOUND_COMPLEX);
+00043         _PatternSound = static_cast<CComplexSound*>(soundPattern);
+00044 
+00045         // read original parameters
+00046         _Gain = soundPattern->getGain();
+00047         _Pitch = soundPattern->getPitch();
+00048         _Looping = soundPattern->getLooping();
+00049         _Priority = soundPattern->getPriority();
+00050         _TickPerSecond = soundPattern->getTicksPerSecond();
+00051 }
+00052 
+00053 CComplexSource::~CComplexSource()
+00054 {
+00055         CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00056         // security
+00057         CAudioMixerUser::instance()->unregisterUpdate(this);
+00058         CAudioMixerUser::instance()->removeEvents(this);
+00059 
+00060         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00061         for (; first != last; ++first)
+00062         {
+00063                 //mixer->removeSource(*first);
+00064                 delete *first;
+00065         }
+00066 }
+00067 
+00068 
+00069 void CComplexSource::setSound( TSoundId id, CSoundContext *context)
+00070 {
+00071 }
+00072 
+00073 TSoundId CComplexSource::getSound()
+00074 {
+00075         return _PatternSound;
+00076 }
+00077 /*
+00078 void CComplexSource::setPriority( TSoundPriority pr, bool redispatch)
+00079 {
+00080 }
+00081 
+00082 void CComplexSource::   setLooping( bool l )
+00083 {
+00084 }
+00085 bool CComplexSource::getLooping() const
+00086 {
+00087         return false;
+00088 }
+00089 */
+00090 
+00091 bool CComplexSource::isPlaying()
+00092 {
+00093         return _Playing;
+00094 }
+00095 
+00096 void CComplexSource::play()
+00097 {
+00098         CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00099         NLMISC::TTime now = NLMISC::CTime::getLocalTime();
+00100 
+00101         switch (_PatternSound->getPatternMode())
+00102         {
+00103         case CComplexSound::MODE_CHAINED:
+00104                 {
+00105                         _SoundSeqIndex = 0;
+00106                         const vector<uint32>    &soundSeq = _PatternSound->getSoundSeq();
+00107                         if (!soundSeq.empty())
+00108                         {
+00109                                 CSound *sound = mixer->getSoundId(_PatternSound->getSound(soundSeq[_SoundSeqIndex++]));
+00110 
+00111                                 if (sound == 0)
+00112                                         return;
+00113                                 
+00114                                 if (_PatternSound->doFadeIn())
+00115                                         _FadeLength = min(uint32(_PatternSound->getFadeLenght()/_TickPerSecond), sound->getDuration() /2);
+00116                                 else
+00117                                         _FadeLength = 0;
+00118 
+00119                                 _Source2 = mixer->createSource(sound, false);
+00120                                 if (_Source2 == NULL)
+00121                                         return;
+00122                                 _Source2->setRelativeGain(0);
+00123                                 _Source2->setPos(_Position);
+00124                                 _Source2->play();
+00125                                 _StartTime2 = now;
+00126 
+00127                                 // register for fade in.
+00128                                 mixer->registerUpdate(this);
+00129                         }
+00130                 }
+00131                 break;
+00132         case CComplexSound::MODE_SPARSE:
+00133                 {
+00134                         // use Source1, sound sequence, delay sequence and event.
+00135                         _SoundSeqIndex = 0;
+00136                         _DelaySeqIndex = 0;
+00137                         const vector<uint32>    &soundSeq = _PatternSound->getSoundSeq();
+00138                         if (!soundSeq.empty())
+00139                         {
+00140                                 CSound *sound = mixer->getSoundId(_PatternSound->getSound(soundSeq[_SoundSeqIndex++]));
+00141 
+00142                                 _Source1 = mixer->createSource(sound, false);
+00143                                 if (_Source1 == NULL)
+00144                                         return;
+00145                                 _Source1->setRelativeGain(_Gain);
+00146                                 _Source1->setPos(_Position);
+00147                                 _Source1->play();
+00148                                 _StartTime1 = now;
+00149 
+00150                                 // register event for next sound.
+00151                                 const std::vector<uint32> &delaySeq = _PatternSound->getDelaySeq();
+00152                                 if (!delaySeq.empty() && _DelaySeqIndex < delaySeq.size())
+00153                                 {
+00154                                         _LastSparseEvent = false;
+00155                                         // event for next sound.
+00156                                         mixer->addEvent(this, uint64(now + sound->getDuration() + delaySeq[_DelaySeqIndex++]/_TickPerSecond));
+00157                                 }
+00158                                 else
+00159                                 {
+00160                                         _LastSparseEvent = true;
+00161                                         // event for stop
+00162                                         mixer->addEvent(this, now + sound->getDuration());
+00163                                 }
+00164                         }
+00165                 }
+00166                 break;
+00167         case CComplexSound::MODE_ALL_IN_ONE:
+00168                 {
+00169                         // just spanw all the listed source.
+00170                         const std::vector<std::string> &sounds = _PatternSound->getSounds();
+00171 
+00172                         std::vector<std::string>::const_iterator first(sounds.begin()), last(sounds.end());
+00173 
+00174                         if (_AllSources.empty())
+00175                         {
+00176                                 // create the sources
+00177                                 for (; first != last; ++first)
+00178                                 {
+00179                                         CSound *sound = mixer->getSoundId(*first);
+00180                                         if (sound != NULL)
+00181                                         {
+00182                                                 USource *source = mixer->createSource(sound, false);
+00183                                                 source->setRelativeGain(_Gain);
+00184                                                 source->setPos(_Position);
+00185                                                 source->play();
+00186                                                 
+00187                                                 _AllSources.push_back(source);
+00188                                         }
+00189                                 }
+00190                         }
+00191                         else
+00192                         {
+00193                                 // just replay the existing source.
+00194                                 std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00195 
+00196                                 for (; first != last; ++first)
+00197                                 {
+00198                                         (*first)->setRelativeGain(_Gain);
+00199                                         (*first)->setPos(_Position);
+00200                                         (*first)->play();
+00201                                 }
+00202                         }
+00203 
+00204                         mixer->addEvent(this, NLMISC::CTime::getLocalTime() + _PatternSound->getDuration());
+00205                 }
+00206                 break;
+00207         default:
+00208                 nldebug("Unknow pattern mode. Can't play.");
+00209         }
+00210 
+00211         CSourceCommon::play();
+00212 }
+00213 void CComplexSource::stop()
+00214 {
+00215         CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00216         if (_Source1)
+00217         {
+00218 //              _Source1->stop();
+00219 //              mixer->removeSource(_Source1);
+00220                 delete _Source1;
+00221 
+00222                 _Source1 = NULL;
+00223         }
+00224         if (_Source2)
+00225         {
+00226 //              _Source2->stop();
+00227 //              mixer->removeSource(_Source2);
+00228                 delete _Source2;
+00229 
+00230                 _Source2 = NULL;
+00231         }
+00232 
+00233         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00234         for (; first != last; ++first)
+00235         {
+00236                 if ((*first)->isPlaying())
+00237                         (*first)->stop();
+00238         }
+00239 
+00240         switch (_PatternSound->getPatternMode())
+00241         {
+00242         case CComplexSound::MODE_CHAINED:
+00243                 mixer->unregisterUpdate(this);
+00244                 mixer->removeEvents(this);
+00245                 break;
+00246         case CComplexSound::MODE_SPARSE:
+00247         case CComplexSound::MODE_ALL_IN_ONE:
+00248                 mixer->removeEvents(this);
+00249                 break;
+00250         }
+00251 
+00252         CSourceCommon::stop();
+00253 }
+00254 
+00255 /*void CComplexSource::unregisterSpawnCallBack()
+00256 {
+00257 }
+00258 */
+00259 void CComplexSource::setPos( const NLMISC::CVector& pos )
+00260 {
+00261         CSourceCommon::setPos(pos);
+00262         
+00263         if (_Source1 != NULL)
+00264                 _Source1->setPos(pos);
+00265         if (_Source2 != NULL)
+00266                 _Source2->setPos(pos);
+00267 
+00268         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00269         for (; first != last; ++first)
+00270         {
+00271                 (*first)->setPos(pos);
+00272         }
+00273 }
+00274 
+00275 void CComplexSource::setVelocity( const NLMISC::CVector& vel )
+00276 {
+00277         CSourceCommon::setVelocity(vel);
+00278         
+00279         if (_Source1 != NULL)
+00280                 _Source1->setVelocity(vel);
+00281         if (_Source2 != NULL)
+00282                 _Source2->setVelocity(vel);
+00283 
+00284         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00285         for (; first != last; ++first)
+00286         {
+00287                 (*first)->setVelocity(vel);
+00288         }
+00289 }
+00290 /*void CComplexSource::getVelocity( NLMISC::CVector& vel ) const
+00291 {
+00292 }
+00293 */
+00294 void CComplexSource::setDirection( const NLMISC::CVector& dir )
+00295 {
+00296         CSourceCommon::setDirection(dir);
+00297         
+00298         if (_Source1 != NULL)
+00299                 _Source1->setDirection(dir);
+00300         if (_Source2 != NULL)
+00301                 _Source2->setDirection(dir);
+00302 
+00303         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00304         for (; first != last; ++first)
+00305         {
+00306                 (*first)->setDirection(dir);
+00307         }
+00308 }
+00309 /*
+00310 void CComplexSource::getDirection( NLMISC::CVector& dir ) const
+00311 {
+00312 }
+00313 */
+00314 void CComplexSource::setGain( float gain )
+00315 {
+00316         CSourceCommon::setGain(gain);
+00317         // update the gain of the played source.
+00318         if (_Source1 != NULL)
+00319                 _Source1->setGain(gain);
+00320         if (_Source2 != NULL)
+00321                 _Source2->setGain(gain);
+00322 
+00323         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00324         for (; first != last; ++first)
+00325         {
+00326                 (*first)->setGain(_Gain);
+00327         }
+00328 }
+00329 
+00330 void CComplexSource::setRelativeGain( float gain )
+00331 {
+00332         CSourceCommon::setRelativeGain(gain);
+00333 
+00334         if (_Source1 != NULL)
+00335                 _Source1->setRelativeGain(gain);
+00336         if (_Source2 != NULL)
+00337                 _Source2->setRelativeGain(gain);
+00338 
+00339         std::vector<USource     *>::iterator first(_AllSources.begin()), last(_AllSources.end());
+00340         for (; first != last; ++first)
+00341         {
+00342                 (*first)->setRelativeGain(_Gain);
+00343         }
+00344 }
+00345 
+00346 /*
+00347 void CComplexSource::setPitch( float pitch )
+00348 {
+00349 }
+00350 float CComplexSource::getPitch() const
+00351 {
+00352         return 0;
+00353 }
+00354 */
+00355 /*
+00356 void CComplexSource::setSourceRelativeMode( bool mode )
+00357 {
+00358 }
+00359 bool CComplexSource::getSourceRelativeMode() const
+00360 {
+00361         return false;
+00362 }
+00363 */
+00364 
+00365 uint32 CComplexSource::getTime()
+00366 {
+00367         // evaluate the elapsed time.
+00368         if (!_Playing || _PlayStart == 0)       // not started ?
+00369                 return 0;
+00370 
+00371         TTime now = NLMISC::CTime::getLocalTime();
+00372 
+00373         TTime delta = now - _PlayStart;
+00374 
+00375         return uint32(delta);
+00376 }
+00377 
+00378 
+00380 void CComplexSource::onUpdate()
+00381 {
+00382         // do the cross fade : 
+00383         //      - lower sound1, louder sound2, 
+00384         //      - when max reach, stop the update, swap the sound, delete sound1 and set event for next fade.
+00385 
+00386         // can only occur for chained mode.
+00387         nlassert(_PatternSound->getPatternMode() == CComplexSound::MODE_CHAINED);
+00388 
+00389         CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00390         
+00391         // compute xfade factor.
+00392         TTime now = NLMISC::CTime::getLocalTime();
+00393         if (_FadeLength > 0)
+00394         {
+00395                 _FadeFactor = float((double(now) - double(_StartTime2)) / double(_FadeLength)) ;
+00396 //              _FadeFactor = (_FadeFactor*_FadeFactor);
+00397         }
+00398         else
+00399                 _FadeFactor = 1.0f;
+00400 
+00401         nldebug("Fade factor = %f", _FadeFactor);
+00402         if (_FadeFactor >= 1.0)
+00403         {
+00404                 // fade end !
+00405                 if (_Source1)
+00406                 {
+00407 //                      _Source1->stop();
+00408 //                      mixer->removeSource(_Source1);
+00409                         delete _Source1;
+00410                         _Source1 = NULL;
+00411                 }
+00412                 if (_Source2)
+00413                 {
+00414                         // set max volume
+00415                         _Source2->setRelativeGain(1.0f * _Gain);
+00416                         // 'swap' the source
+00417                         _Source1 = _Source2;
+00418                         _StartTime1 = _StartTime2;
+00419                         _Source2 = NULL;
+00420                         // if there is a next sound available, program an event for the next xfade.
+00421                         CSound  *sound2 = NULL;
+00422 //                      _SoundSeqIndex++;
+00423                         const vector<uint32>    &soundSeq = _PatternSound->getSoundSeq();
+00424                         if (_SoundSeqIndex < soundSeq.size())
+00425                         {
+00426                                 sound2 = mixer->getSoundId(_PatternSound->getSound(soundSeq[_SoundSeqIndex++]));
+00427                         }
+00428                         else if (_Looping)
+00429                         {
+00430                                 // restart the sound sequence
+00431                                 _SoundSeqIndex = 0;
+00432                                 sound2 = mixer->getSoundId(_PatternSound->getSound(soundSeq[_SoundSeqIndex++]));
+00433                         }
+00434                                 
+00435 
+00436                         if (sound2 != NULL)
+00437                         {
+00438                                 nldebug("CS : Chaining to sound %s", sound2->getName().c_str());
+00439                                 CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00440 
+00441                                 // determine the XFade lenght (if next sound is too short.
+00442                                 _FadeLength = minof<uint32>(uint32(_PatternSound->getFadeLenght()/_TickPerSecond), sound2->getDuration() / 2, _Source1->getSound()->getDuration()/2);
+00443                                 _Source2 = mixer->createSource(sound2, false);
+00444                                 // there is a next sound, add event for xfade.
+00445                                 nldebug("Seting event for sound %s in %u millisec (XFade = %u).", _Source1->getSound()->getName().c_str(), _Source1->getSound()->getDuration(), _FadeLength);
+00446                                 mixer->addEvent(this, _StartTime1 + _Source1->getSound()->getDuration() - _FadeLength);
+00447                         }
+00448                         else
+00449                         {
+00450                                 // no sound after, just set an event at end of current sound to stop the complex sound.
+00451                                 nldebug("Setting last event for sound %s in %u millisec.", _Source1->getSound()->getName().c_str(), _Source1->getSound()->getDuration());
+00452                                 if (_PatternSound->doFadeOut())
+00453                                 {
+00454                                         // set the event to begin fade out.
+00455                                         mixer->addEvent(this, _StartTime1 + _Source1->getSound()->getDuration() - _PatternSound->getFadeLenght());
+00456                                 }
+00457                                 else
+00458                                 {
+00459                                         // set the event at end of sound.
+00460                                         mixer->addEvent(this, _StartTime1 + _Source1->getSound()->getDuration());
+00461                                 }
+00462                         }
+00463                 }
+00464                 else
+00465                 {
+00466                         if (_PatternSound->doFadeOut())
+00467                         {
+00468                                 // update is responsible for stoping the sound.
+00469                                 _Playing = false;
+00470                         }
+00471                 }
+00472                 // remove from the update list
+00473                 mixer->unregisterUpdate(this);
+00474         }
+00475         else
+00476         {
+00477                 // do the xfade
+00478                 if (_Source1)
+00479                 {
+00480                         // lower the sound 1.
+00481                         _Source1->setRelativeGain(float(1.0 - _FadeFactor) * _Gain);
+00482 
+00483                 }
+00484                 if (_Source2)
+00485                 {
+00486                         // lower the sound 1.
+00487 //                      _Source2->setRelativeGain(float(sqrt(_FadeFactor)) * _Gain);
+00488                         _Source2->setRelativeGain(float(_FadeFactor) * _Gain);
+00489                 }
+00490         }
+00491 }
+00493 void CComplexSource::onEvent()
+00494 {
+00495         CAudioMixerUser *mixer = CAudioMixerUser::instance();
+00496         NLMISC::TTime now = NLMISC::CTime::getLocalTime();
+00497 
+00498         switch (_PatternSound->getPatternMode())
+00499         {
+00500         case CComplexSound::MODE_CHAINED:
+00501                 {
+00502                         // either it's time to begin a new xfade, or to end this sound.
+00503                         if (_Source2 != NULL)
+00504                         {
+00505                                 // start new cross fade.?
+00506                                 _StartTime2 = now;
+00507                                 // mute the source2
+00508                                 _Source2->setRelativeGain(0);
+00509                                 // start the source 2
+00510                                 _Source2->play();
+00511                                 // register for update.
+00512                                 mixer->registerUpdate(this);
+00513                         }
+00514                         else
+00515                         {
+00516                                 if (_PatternSound->doFadeOut())
+00517                                 {
+00518                                         // set in update list for fade out.
+00519                                         _StartTime2 = now;
+00520                                         mixer->registerUpdate(this);
+00521                                 }
+00522                                 else
+00523                                 {
+00524                                         // end the sound.
+00525 //                                      _Source1->stop();
+00526 //                                      mixer->removeSource(_Source1);
+00527                                         delete _Source1;
+00528                                         _Source1 = NULL;
+00529                                         _Playing = false;
+00530                                 }
+00531                         }
+00532                 }
+00533                 break;
+00534         case CComplexSound::MODE_SPARSE:
+00535                 {
+00536                         if (_Source1 != NULL)
+00537                         {
+00538 //                              _Source1->stop();
+00539 //                              mixer->removeSource(_Source1);
+00540                                 delete _Source1;
+00541                                 _Source1 = NULL;
+00542                         }
+00543 
+00544                         const std::vector<uint32> &delaySeq = _PatternSound->getDelaySeq();
+00545                         const vector<uint32>    &soundSeq = _PatternSound->getSoundSeq();
+00546 
+00547                         if (_Looping && _DelaySeqIndex >= delaySeq.size())
+00548                         {
+00549                                 _DelaySeqIndex = 0;
+00550                         }
+00551 
+00552                         if (!soundSeq.empty() && !_LastSparseEvent)
+00553                         {
+00554                                 // wrap around sound sequence until there are delays...
+00555                                 if (_SoundSeqIndex >= soundSeq.size())
+00556                                         _SoundSeqIndex = 0;
+00557 
+00558                                 CSound *sound = mixer->getSoundId(_PatternSound->getSound(soundSeq[_SoundSeqIndex++]));
+00559 
+00560                                 _Source1 = mixer->createSource(sound, false);
+00561                                 if (_Source1 == NULL)
+00562                                 {
+00563                                         stop();
+00564                                         return;
+00565                                 }
+00566                                 _Source1->setRelativeGain(_Gain);
+00567                                 _Source1->setPos(_Position);
+00568                                 _Source1->play();
+00569                                 _StartTime1 = now;
+00570 
+00571                                 // register event for next sound.
+00572                                 if (!delaySeq.empty() && _DelaySeqIndex < delaySeq.size())
+00573                                 {
+00574                                         // event for next sound.
+00575                                         mixer->addEvent(this, uint64(now + sound->getDuration() + delaySeq[_DelaySeqIndex++]/_TickPerSecond));
+00576                                 }
+00577                                 else
+00578                                 {
+00579                                         // event for stop
+00580                                         _LastSparseEvent = true;
+00581                                         mixer->addEvent(this, now + sound->getDuration());
+00582                                 }
+00583                         }
+00584                         else
+00585                         {
+00586                                 // this is the event for stop !
+00587                                 stop();
+00588                         }
+00589                 }
+00590                 break;
+00591         case CComplexSound::MODE_ALL_IN_ONE:
+00592                 // just call the stop method.
+00593                 stop();
+00594                 break;
+00595         default:
+00596                 nlassert(false);
+00597         }
+00598 }
+00599 
+00600 
+00601 
+00602 } // NLSOUND
+
complex_source.cpp
