nevrax.org : docs

00001 
00007 /* Copyright, 2000, 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 #error "Deprecated"
00027 
00028 #include "stdsound.h"
00029 
00030 #include "ambiant_source.h"
00031 #include "sound.h"
00032 
00033 using namespace NLMISC;
00034 using namespace std;
00035 
00036 
00037 namespace NLSOUND {
00038 
00039 
00040 // If this flag is defined, one ambiant sound cannot be the next one to itself
00041 #define ENVSOUND_DONT_DUPLICATE_AMBIANT
00042 
00043 
00044 /*
00045  * Constructor
00046  */
00047 CAmbiantSource::CAmbiantSource() : _Play(false),
00048                                                                    _StereoGain(0.0f),
00049                                                                    _Sustain(false),
00050                                                                    _RandomSoundChosen(false),
00051                                                                    _NextSparseSoundTime(0),
00052                                                                    _CrossfadeTime(4000),
00053                                                                    _SustainTime(8000),
00054                                                                    _SparseAvgPeriod(20000)
00055 {
00056         _StereoChannels[AMBIANT_CH1].setLooping( true );
00057         _StereoChannels[AMBIANT_CH2].setLooping( true );
00058         //_StereoChannels[SPARSE_CH].setLooping( false );
00059 
00060         srand( (uint32)CTime::getLocalTime() );
00061 }
00062 
00063 
00064 /*
00065  * Destructor
00066  */
00067 CAmbiantSource::~CAmbiantSource()
00068 {
00069         CAudioMixerUser::instance()->removeMySource( &_StereoChannels[AMBIANT_CH1] );
00070         CAudioMixerUser::instance()->removeMySource( &_StereoChannels[AMBIANT_CH2] );
00071         CAudioMixerUser::instance()->removeMySource( &_StereoChannels[SPARSE_CH] );
00072 
00073         // Delete sounds: now done in CAudioMixerUser::~CAudioMixerUser()
00074         /*vector<CSound*>::iterator ipsnds;
00075         for ( ipsnds=_AmbiantSounds.begin(); ipsnds!=_AmbiantSounds.end(); ++ipsnds )
00076         {
00077                 nldebug( "Deleting ambiant sound" );
00078                 delete (*ipsnds);
00079         }
00080         for ( ipsnds=_SparseSounds.begin(); ipsnds!=_SparseSounds.end(); ++ipsnds )
00081         {
00082                 nldebug( "Deleting sparse sound" );
00083                 delete (*ipsnds);
00084         }
00085         */
00086 }
00087 
00088 
00089 /* Init. You can pass a position vector to link to (if the playable has stereo source(s))
00090  * When reading from a stream, call init() *after* serial().
00091  */
00092 void CAmbiantSource::initPos( const CVector *posvector )
00093 {
00094         // Initialize ambiant sound channels
00095         if ( ! _AmbiantSounds.empty()  )
00096         {
00097                 _StereoChannels[AMBIANT_CH1].set3DPositionVector( posvector );
00098                 _StereoChannels[AMBIANT_CH1].setSound( getRandomSound( _AmbiantSounds ) );
00099                 _StereoChannels[AMBIANT_CH1].setGain( 0.0f );
00100                 _StereoChannels[AMBIANT_CH1].setPriority( LowPri);
00101                 CAudioMixerUser::instance()->addSource( &_StereoChannels[AMBIANT_CH1] );
00102                 CAudioMixerUser::instance()->giveTrack( &_StereoChannels[AMBIANT_CH1] );
00103                 
00104                 if ( _AmbiantSounds.size() > 1 )
00105                 {
00106                         _StereoChannels[AMBIANT_CH2].set3DPositionVector( posvector );
00107                         _StereoChannels[AMBIANT_CH2].setSound( getRandomSound( _AmbiantSounds ) );
00108                         _StereoChannels[AMBIANT_CH2].setGain( 0.0f );
00109                         _StereoChannels[AMBIANT_CH2].setPriority( LowPri);
00110                         CAudioMixerUser::instance()->addSource( &_StereoChannels[AMBIANT_CH2] );
00111                         CAudioMixerUser::instance()->giveTrack( &_StereoChannels[AMBIANT_CH2] );
00112                 }
00113         }
00114 
00115         // Initialize sparse sounds channel
00116         if ( ! _SparseSounds.empty() )
00117         {
00118                 _StereoChannels[SPARSE_CH].set3DPositionVector( posvector );
00119                 _StereoChannels[SPARSE_CH].setPriority( LowPri );
00120                 _StereoChannels[SPARSE_CH].setSound( getRandomSound( _SparseSounds ) );
00121                 CAudioMixerUser::instance()->addSource( &_StereoChannels[SPARSE_CH] );
00122                 CAudioMixerUser::instance()->giveTrack( &_StereoChannels[SPARSE_CH] );
00123         }
00124 }
00125 
00126 
00127 /*
00128  * Enable (play with high priority) and set general gain, or disable (stop and set low priority).
00129  */
00130 void                    CAmbiantSource::enable( bool toplay, float gain )
00131 {
00132         // Calc position in cycle
00133         bool crossfade;
00134         uint32 leadchannel;
00135         if ( _AmbiantSounds.size() > 1 )
00136         {
00137                 calcPosInCycle( crossfade, leadchannel );
00138         }
00139         else
00140         {
00141                 crossfade = false;
00142                 leadchannel = AMBIANT_CH1;
00143         }
00144 
00145         // Enable/disable
00146         if ( toplay )
00147         {
00148                 _StereoGain = gain;
00149 
00150                 if ( ! _Play )
00151                 {
00152                         // Start lead channel
00153                         if ( _StereoChannels[leadchannel].getSound() != NULL )
00154                         {
00155                                 nldebug( "AM: Envsound: Switch on channel %u", leadchannel );
00156                                 _StereoChannels[leadchannel].setPriority( HighPri ) ;
00157                                 _StereoChannels[leadchannel].play();
00158                         }
00159 
00160                         // If crossfading, start back channel
00161                         if ( crossfade && (_StereoChannels[1-leadchannel].getSound() != NULL) )
00162                         {
00163                                 nldebug( "AM: Envsound: Switch on channel %u", 1-leadchannel );
00164                                 _StereoChannels[1-leadchannel].setPriority( HighPri ) ;
00165                                 _StereoChannels[1-leadchannel].play();
00166                         }
00167 
00168                         // Calc when the next spare sound will play
00169                         calcRandomSparseSoundTime( NULL );
00170 
00171                         _Play = true;
00172                 }
00173                 // The SPARSE_CH is added only when needed
00174         }
00175         else
00176         {
00177                 if ( _Play )
00178                 {
00179                         // Stop lead channel
00180                         if ( _StereoChannels[leadchannel].getSound() != NULL )
00181                         {
00182                                 nldebug( "AM: Envsound: Switch off channel %u", leadchannel );
00183                                 _StereoChannels[leadchannel].stop();
00184                                 _StereoChannels[leadchannel].setPriority( LowPri );
00185                         }
00186 
00187                         // If crossfading, stop back channel
00188                         if ( crossfade && (_StereoChannels[1-leadchannel].getSound() != NULL) )
00189                         {
00190                                 nldebug( "AM: Envsound: Switch off channel %u", 1-leadchannel );
00191                                 _StereoChannels[1-leadchannel].stop();
00192                                 _StereoChannels[1-leadchannel].setPriority( LowPri );
00193                         }
00194 
00195                         // Stop spare channel, anyway
00196                         if ( _StereoChannels[SPARSE_CH].getSound() != NULL )
00197                         {
00198                                 nldebug( "AM: Envsound: Switch off sparse channel" );
00199                                 _StereoChannels[SPARSE_CH].stop();
00200                                 _StereoChannels[SPARSE_CH].setPriority( LowPri );
00201                         }
00202 
00203                         _Play = false;
00204                 }
00205         }
00206 }
00207 
00208 
00209 /*
00210  * Calc pos in cycle
00211  */
00212 TTime CAmbiantSource::calcPosInCycle( bool& crossfade, uint32& leadchannel )
00213 {
00214         TTime pos = CTime::getLocalTime();
00215         uint32 cycletime = _CrossfadeTime + _SustainTime;
00216         pos = pos % (cycletime*2);
00217 
00218         // Calc which channel will be the lead one
00219         if ( pos < cycletime )
00220         {
00221                 leadchannel = 0;
00222         }
00223         else
00224         {
00225                 leadchannel = 1;
00226                 pos = pos - (cycletime);
00227         }
00228 
00229         // Calc if the pos is in the first part (crossfade) or in the other part (sustain)
00230         crossfade = ( pos < _CrossfadeTime );
00231         
00232         return pos;
00233 }
00234 
00235 
00236 /*
00237  * Update the stereo mix (call evenly)
00238  */
00239 void CAmbiantSource::update()
00240 {
00241         if ( (!_Play) || (_StereoGain==0.0f) )
00242         {
00243                 return;
00244         }
00245 
00246         // Calc pos in cycle
00247         bool crossfade;
00248         uint32 leadchannel, backchannel=0;
00249         TTime posInCycle=0;
00250         if ( _AmbiantSounds.size() > 1 )
00251         {
00252                 posInCycle = calcPosInCycle( crossfade, leadchannel );
00253                 backchannel = 1 - leadchannel;
00254         }
00255         else
00256         {
00257                 // If there is less than 2 sounds, no crossfade, always sustain (a single sound must be looping)
00258                 crossfade = false;
00259                 leadchannel = AMBIANT_CH1;
00260                 _Sustain = true;
00261         }
00262         
00263         // Crossfade the first two sources
00264         if ( crossfade )
00265         {
00266                 // Attack
00267                 float ratio = (float)posInCycle / (float)_CrossfadeTime;
00268                 _StereoChannels[leadchannel].setRelativeGain( ratio*_StereoGain );
00269                 _StereoChannels[backchannel].setRelativeGain( (1.0f - ratio)*_StereoGain );
00270 
00271                 // Start next sound
00272                 if ( _Sustain )
00273                 {
00274                         nldebug( "AM: EnvSound: Beginning crossfade: channel #%u rising", leadchannel );
00275                         _StereoChannels[leadchannel].setPriority( HighPri ) ;
00276                         _StereoChannels[leadchannel].play();
00277                         _Sustain = false;
00278                 }
00279         }
00280         else
00281         {
00282                 // Set sustain gain (takes into account the possible changes to _StereoGain)
00283                 _StereoChannels[leadchannel].setRelativeGain( _StereoGain );
00284 
00285                 // Prepare next ambiant sound
00286                 if ( ! _Sustain )
00287                 {
00288                         _Sustain = true;
00289                         TSoundId nextsound = getRandomSound( _AmbiantSounds );
00290 #ifdef ENVSOUND_DONT_DUPLICATE_AMBIANT
00291                         nlassert( _AmbiantSounds.size() > 1 ); // or infinite loop
00292                         while ( nextsound == _StereoChannels[leadchannel].getSound() )
00293                         {
00294                                 nldebug( "AM: EnvSound: Avoiding ambiant sound duplication..." );
00295                                 nextsound = getRandomSound( _AmbiantSounds );
00296                         }
00297 #endif
00298                         nldebug( "AM: EnvSound: Sustain: channel #1" );
00299                         _StereoChannels[backchannel].setRelativeGain( 0.0f );
00300                         _StereoChannels[backchannel].stop(); // we don't set the priority to LowPri
00301                         _StereoChannels[backchannel].setSound( nextsound );
00302                 }
00303         }
00304 
00305         // Add a short random sound into the third source
00306         if ( ! _SparseSounds.empty() )
00307         {
00308                 // Set sustain gain (takes into account the possible changes to _StereoGain)
00309                 _StereoChannels[SPARSE_CH].setRelativeGain( _StereoGain );
00310 
00311                 // Start next sparse sound
00312                 TTime now = CTime::getLocalTime();
00313                 if ( now > _NextSparseSoundTime )
00314                 {
00315                         TSoundId nextsound = getRandomSound( _SparseSounds );
00316                         _StereoChannels[SPARSE_CH].stop();
00317                         _StereoChannels[SPARSE_CH].setSound( nextsound );
00318                         _StereoChannels[SPARSE_CH].setPriority( MidPri );
00319                         _StereoChannels[SPARSE_CH].play();
00320                         nldebug( "AM: EnvSound: Playing sparse sound" );
00321                         if ( _StereoChannels[SPARSE_CH].getTrack() == NULL )
00322                         {
00323                                 nldebug( "AM: Ensound: Switch on sparse channel" );
00324                                 nlassert( _StereoChannels[SPARSE_CH].getSound() != NULL );
00325                         }
00326                         // Does not leave the track
00327                         calcRandomSparseSoundTime( nextsound );
00328                 }
00329         }
00330 }
00331 
00332 
00333 /*
00334  * Select a random sound in a bank
00335  */
00336 TSoundId        CAmbiantSource::getRandomSound( const std::vector<CSound*>& bank ) const
00337 {
00338         nlassert( ! bank.empty() );
00339         // Note: does not work with a very big size (rand()*bank.size() would overflow)
00340         uint32 r = rand()*bank.size()/(RAND_MAX+1);
00341         nlassert( r < bank.size() );
00342         nldebug( "AM: EnvSound: Prepared random sound number %u of %u", r, bank.size()-1 );
00343 
00344         return bank[r];
00345 }
00346 
00347 
00348 
00349 
00350 /*
00351  * Calculate the next time a sparse sound plays
00352  */
00353 void            CAmbiantSource::calcRandomSparseSoundTime( TSoundId currentsparesound )
00354 {
00355         uint32 delay = (uint)((float)rand() * (float)(_SparseAvgPeriod*2) / (float)RAND_MAX);
00356 
00357         // Check the next sound will play after the current one
00358         if ( currentsparesound != NULL )
00359         {
00360                 uint32 soundlength = currentsparesound->getDuration();
00361                 if ( delay <= soundlength )
00362                 {
00363                         delay = soundlength+1;
00364                 }
00365         }
00366 
00367         nldebug( "AM: EnvSound: Next sparse sound will play in %u ms", delay );
00368         _NextSparseSoundTime = CTime::getLocalTime() + delay;
00369 }
00370 
00371 
00372 /*
00373  * Serialize
00374  */
00375 /*
00376 void                                    CAmbiantSource::serial( NLMISC::IStream& s )
00377 {
00378         // If you change this, increment the version number in CEnvSoundUser::load() !
00379 
00380         // Constants
00381         s.serial( _CrossfadeTime );
00382         s.serial( _SustainTime );
00383         s.serial( _SparseAvgPeriod );
00384 
00385         // Stereo sound banks (sounds allocated here once per pointer, deleted by CAudioMixerUser::~CAudioMixerUser())
00386         s.serialContPtr( _AmbiantSounds );
00387         s.serialContPtr( _SparseSounds );
00388 
00389         // Register within the audio mixer for deletion at the end
00390         vector<CSound*>::iterator ips;
00391         for ( ips=_AmbiantSounds.begin(); ips!=_AmbiantSounds.end(); ++ips )
00392         {
00393                 CAudioMixerUser::instance()->addAmbiantSound( (*ips) );
00394         }
00395         for ( ips=_SparseSounds.begin(); ips!=_SparseSounds.end(); ++ips )
00396         {
00397                 CAudioMixerUser::instance()->addAmbiantSound( (*ips) );
00398         }
00399 }
00400 
00401 */
00402 
00403 /*
00404  * Set properties (EDIT)
00405  */
00406 void            CAmbiantSource::setProperties( std::vector<TSoundId>& ambiantsounds,
00407                                                                                    std::vector<TSoundId>& sparsesounds,
00408                                                                                    uint32 crossfadeTimeMs, uint32 sustainTimeMs,
00409                                                                                    uint32 sparseAvgPeriodMs )
00410 {
00411         _AmbiantSounds = ambiantsounds;
00412         _SparseSounds = sparsesounds;
00413         _CrossfadeTime = crossfadeTimeMs;
00414         _SustainTime = sustainTimeMs;
00415         _SparseAvgPeriod = sparseAvgPeriodMs;
00416 }
00417 
00418 
00419 } // NLSOUND
ambiant_source.cpp
