nel/src/3d/ps_sound.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2012-2019  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21 #include "nel/misc/string_mapper.h"
  22 #include "nel/3d/ps_sound.h"
  23 #include "nel/3d/particle_system.h"
  24 #include "nel/3d/u_ps_sound_interface.h"
  25 #include "nel/3d/ps_attrib_maker.h"
  26
  27 using namespace NLMISC;
  28
  29 #ifdef DEBUG_NEW
  30 #define new DEBUG_NEW
  31 #endif
  32
  33 namespace NL3D
  34 {
  35
  36
  37 // we batch computation of Gains and frequencies. Here is the buffer size:
  38 static const uint SoundBufSize = 1024;
  39
  40
  41 // ***************************************************************************************************
  42 CPSSound::CPSSound() : _Gain(1.f),
  43                                            _GainScheme(NULL),
  44                                            _Pitch(1.f),
  45                                            _PitchScheme(NULL),
  46                                            _EmissionPercent(1),
  47                                            _SpawnSounds(false),
  48                                            _Mute(false),
  49                                            _SoundStopped(false),
  50                                            _SoundReactivated(false),
  51                                            _UseOriginalPitch(false)
  52 {
  53         NL_PS_FUNC(CPSSound_CPSSound)
  54         if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("sound");
  55         _SoundName = NLMISC::CStringMapper::emptyId();
  56 }
  57
  58 // ***************************************************************************************************
  59 void    CPSSound::stopSound()
  60 {
  61         NL_PS_FUNC(CPSSound_stopSound)
  62         _SoundReactivated = false;
  63         if (_SoundStopped) return;
  64         CPSAttrib<UPSSoundInstance *>::iterator it = _Sounds.begin()
  65                                                                                                 , endIt = _Sounds.end();
  66         while (it != endIt)
  67         {
  68                 if (*it)
  69                 {
  70                         (*it)->setLooping(false);
  71                         (*it)->release();
  72                         (*it) = NULL;
  73                 }
  74                 ++it;
  75         }
  76         _SoundStopped = true;
  77 }
  78
  79 // ***************************************************************************************************
  80 void    CPSSound::reactivateSound()
  81 {
  82         NL_PS_FUNC(CPSSound_reactivateSound)
  83         //if (!_SoundStopped) return;
  84         _SoundReactivated  = true;
  85 }
  86
  87 // ***************************************************************************************************
  88 void CPSSound::removeAllSources(void)
  89 {
  90         NL_PS_FUNC(CPSSound_removeAllSources)
  91         const sint32 size = _Sounds.getSize();
  92         // delete all sounds, and rebuild them all
  93         for (sint32 k = size - 1; k >= 0; --k)
  94         {
  95                 deleteElement(k);
  96         }
  97 }
  98
  99 // ***************************************************************************************************
 100 CPSSound::~CPSSound()
 101 {
 102         NL_PS_FUNC(CPSSound_CPSSound)
 103         removeAllSources();
 104         delete _GainScheme;
 105         delete _PitchScheme;
 106 }
 107
 108 // ***************************************************************************************************
 109 uint32                  CPSSound::getType(void) const
 110 {
 111         NL_PS_FUNC(CPSSound_getType)
 112         return PSSound;
 113 }
 114
 115
 116
 117 // ***************************************************************************************************
 118 void                    CPSSound::step(TPSProcessPass pass)
 119 {
 120         NL_PS_FUNC(CPSSound_step)
 121         if (pass != PSMotion) return;
 122         const uint32 size = _Owner->getSize();
 123         if (!size) return;
 124         if (_SoundStopped && !_SoundReactivated)
 125         {
 126                 return;
 127         }
 128         if (_SoundReactivated)
 129         {
 130                 _SoundStopped = false;
 131                 _SoundReactivated = false;
 132                 if (!_Mute)
 133                 {
 134                         sint32 k;
 135                         // delete all sounds, and rebuild them all
 136                         removeAllSources();
 137                         for (k = 0; k < (sint32) size; ++k)
 138                         {
 139                                 CPSEmitterInfo ei;
 140                                 ei.setDefaults();
 141                                 newElement(ei);
 142                         }
 143                 }
 144                 // don't need to reupdate sound
 145                 return;
 146         }
 147         nlassert(_Owner);
 148         uint32 toProcess, leftToDo = size;
 149
 150         float   Gains[SoundBufSize];
 151         float   frequencies[SoundBufSize];
 152
 153         uint    GainPtInc    = _GainScheme ? 1 : 0;
 154         uint    pitchPtInc = _PitchScheme ? 1 : 0;
 155         float   *currVol, *currPitch;
 156
 157
 158         CPSAttrib<UPSSoundInstance *>::iterator it = _Sounds.begin(),
 159                                                                                                  endIt;
 160         CPSAttrib<NLMISC::CVector>::const_iterator posIt = _Owner->getPos().begin();
 161         CPSAttrib<NLMISC::CVector>::const_iterator speedIt = _Owner->getSpeed().begin();
 162
 163         do
 164         {
 165                 toProcess = leftToDo > SoundBufSize ? SoundBufSize : leftToDo;
 166                 // compute Gain
 167                 currVol = _GainScheme ? (float *) _GainScheme->make(getOwner(), size - leftToDo, Gains, sizeof(float), toProcess, true)
 168                                                           : &_Gain;
 169                 if (!_UseOriginalPitch)
 170                 {
 171                         // compute pitch
 172                         currPitch = _PitchScheme ? (float *) _PitchScheme->make(getOwner(), size - leftToDo, frequencies, sizeof(float), toProcess, true)
 173                                                                                  : &_Pitch;
 174                         endIt = it + toProcess;
 175                         const CMatrix &localToWorld = _Owner->getLocalToWorldMatrix();
 176                         do
 177                         {
 178                                 if (*it) // was this sound instanciated?
 179                                 {
 180                                         (*it)->setSoundParams(*currVol,
 181                                                                                   localToWorld * *posIt,
 182                                                                                   localToWorld.mulVector(*speedIt),
 183                                                                                   *currPitch);
 184                                         if ((*it)->isLooping() && !(*it)->isPlaying())
 185                                         {
 186                                                 // looping sources do not play when they are clipped, so "reminds" the source to play when possible.
 187                                                 (*it)->play();
 188                                         }
 189                                 }
 190                                 currVol += GainPtInc;
 191                                 currPitch += pitchPtInc;
 192                                 ++posIt;
 193                                 ++speedIt;
 194                                 ++it;
 195                         }
 196                         while (it != endIt);
 197                 }
 198                 else
 199                 {
 200                         // keep original pitch
 201                         endIt = it + toProcess;
 202                         const CMatrix &localToWorld = _Owner->getLocalToWorldMatrix();
 203                         do
 204                         {
 205                                 if (*it) // was this sound instanciated?
 206                                 {
 207                                         (*it)->setSoundParams(*currVol,
 208                                                 localToWorld * *posIt,
 209                                                 localToWorld.mulVector(*speedIt),
 210                                                 (*it)->getPitch());
 211                                 }
 212                                 currVol += GainPtInc;
 213                                 ++posIt;
 214                                 ++speedIt;
 215                                 ++it;
 216                         }
 217                         while (it != endIt);
 218                 }
 219                 leftToDo -= toProcess;
 220         }
 221         while (leftToDo);
 222 }
 223
 224 // ***************************************************************************************************
 225 void    CPSSound::setGain(float Gain)
 226 {
 227         NL_PS_FUNC(CPSSound_setGain)
 228         delete _GainScheme;
 229         _GainScheme = NULL;
 230         _Gain = Gain;
 231 }
 232
 233 // ***************************************************************************************************
 234 void    CPSSound::setGainScheme(CPSAttribMaker<float> *Gain)
 235 {
 236         NL_PS_FUNC(CPSSound_setGainScheme)
 237         delete _GainScheme;
 238         _GainScheme = Gain;
 239         if (_Owner)
 240         {
 241                 if (_GainScheme && _GainScheme->hasMemory()) _GainScheme->resize(_Owner->getMaxSize(), _Owner->getSize());
 242         }
 243 }
 244
 245 // ***************************************************************************************************
 246 void    CPSSound::setPitch(float pitch)
 247 {
 248         NL_PS_FUNC(CPSSound_setPitch)
 249         delete _PitchScheme;
 250         _PitchScheme = NULL;
 251         _Pitch = pitch;
 252 }
 253
 254 // ***************************************************************************************************
 255 void    CPSSound::setPitchScheme(CPSAttribMaker<float> *pitch)
 256 {
 257         NL_PS_FUNC(CPSSound_setPitchScheme)
 258         delete _PitchScheme;
 259         _PitchScheme = pitch;
 260         if (_Owner)
 261         {
 262                 if (_PitchScheme && _PitchScheme->hasMemory()) _PitchScheme->resize(_Owner->getMaxSize(), _Owner->getSize());
 263         }
 264 }
 265
 266 // ***************************************************************************************************
 267 void                    CPSSound::serial(NLMISC::IStream &f)
 268 {
 269         NL_PS_FUNC(CPSSound_serial)
 270         CPSLocatedBindable::serial(f);
 271         // version 3 : added option to keep original pitch from the .sound
 272         sint ver = f.serialVersion(3);
 273
 274         // FIXME: CPSSound is reserialized from the _ParticleSystemProto
 275         // cache when a non-_Shared particle system is instanced, this
 276         // causes unnecessary id lookups from string.
 277         if (f.isReading())
 278         {
 279                 std::string soundName;
 280                 f.serial(soundName);
 281                 _SoundName = NLMISC::CStringMapper::map(soundName);
 282         }
 283         else
 284         {
 285                 std::string soundName = NLMISC::CStringMapper::unmap(_SoundName);
 286                 f.serial(soundName);
 287         }
 288
 289         sint32 nbSounds;
 290         bool hasScheme;
 291         if (f.isReading())
 292         {
 293                 f.serial(nbSounds); // we are very unlikely to save a system with sounds being played in it,
 294                                                         // but we need to keep datas coherency.
 295                 if (_Owner)
 296                 {
 297                         _Sounds.resize(_Owner->getMaxSize());
 298                 }
 299         }
 300         else
 301         {
 302                 nbSounds = _Sounds.getSize(); // number of used sound
 303                 f.serial(nbSounds);
 304         }
 305
 306
 307         if (f.isReading())
 308         {
 309                 delete _GainScheme;
 310                 _GainScheme = NULL;
 311                 delete _PitchScheme;
 312                 _PitchScheme = NULL;
 313         }
 314         // save Gain infos
 315         hasScheme = _GainScheme != NULL;
 316         f.serial(hasScheme);
 317         if (hasScheme)
 318         {
 319                 f.serialPolyPtr(_GainScheme);
 320         }
 321         else
 322         {
 323                 f.serial(_Gain);
 324         }
 325         // serial pitch infos
 326         if (ver >= 3)
 327         {
 328                 bool useOriginalPitch = _UseOriginalPitch;
 329                 f.serial(useOriginalPitch);
 330                 _UseOriginalPitch = useOriginalPitch;
 331                 if (!_UseOriginalPitch)
 332                 {
 333                         // serialize pitch infos (no needed otherwise)
 334                         hasScheme = _PitchScheme != NULL;
 335                         f.serial(hasScheme);
 336                         if (hasScheme)
 337                         {
 338                                 f.serialPolyPtr(_PitchScheme);
 339                         }
 340                         else
 341                         {
 342                                 f.serial(_Pitch);
 343                         }
 344                 }
 345         }
 346         else
 347         {
 348                 hasScheme = _PitchScheme != NULL;
 349                 f.serial(hasScheme);
 350                 if (hasScheme)
 351                 {
 352                         f.serialPolyPtr(_PitchScheme);
 353                 }
 354                 else
 355                 {
 356                         f.serial(_Pitch);
 357                 }
 358         }
 359
 360         if (ver > 1)
 361         {
 362                 f.serial(_EmissionPercent);
 363                 f.serial(_SpawnSounds);
 364         }
 365
 366         if (f.isReading())
 367         {
 368                 _SoundStopped = true;
 369                 // insert blank sources
 370                 for (sint k = 0; k < nbSounds; ++k)
 371                 {
 372                         CPSEmitterInfo ei;
 373                         ei.setDefaults();
 374                         newElement(ei);
 375                 }
 376                 _SoundStopped = false;
 377                 _SoundReactivated = true;
 378         }
 379 }
 380
 381
 382 // ***************************************************************************************************
 383 void                    CPSSound::newElement(const CPSEmitterInfo &info)
 384 {
 385         NL_PS_FUNC(CPSSound_newElement)
 386         nlassert(_Owner);
 387         if (_GainScheme && _GainScheme->hasMemory()) _GainScheme->newElement(info);
 388         if (_PitchScheme && _PitchScheme->hasMemory()) _PitchScheme->newElement(info);
 389         // if there's a sound server, we generate a new sound instance
 390         if (!_Mute && !_SoundStopped && CParticleSystem::getSoundServer())
 391         {
 392                 if ((rand() % 99) * 0.01f < _EmissionPercent)
 393                 {
 394                         uint32 index = _Sounds.insert(CParticleSystem::getSoundServer()->createSound(_SoundName, _SpawnSounds));
 395
 396
 397
 398                         /// set position and activate the sound
 399                         if (_Sounds[index])
 400                         {
 401                                 const NLMISC::CMatrix &mat = getLocalToWorldMatrix();
 402                                 float pitch;
 403                                 if (_UseOriginalPitch)
 404                                 {
 405                                         pitch = _Sounds[index]->getPitch();
 406                                 }
 407                                 else
 408                                 {
 409                                         pitch = _PitchScheme ? _PitchScheme->get(getOwner(), 0) : _Pitch;
 410                                 }
 411                                 _Sounds[index]->setSoundParams(_GainScheme ? _GainScheme->get(getOwner(), 0) : _Gain,
 412                                                                                            mat * _Owner->getPos()[index],
 413                                                                                            _Owner->getSpeed()[index],
 414                                                                                            pitch
 415                                                                                           );
 416                                 _Sounds[index]->play();
 417                         }
 418                 }
 419                 else
 420                 {
 421                         _Sounds.insert(NULL);
 422                 }
 423         }
 424         else
 425         {
 426                 _Sounds.insert(NULL);
 427         }
 428 }
 429
 430 // ***************************************************************************************************
 431 void    CPSSound::deleteElement(uint32 index)
 432 {
 433         NL_PS_FUNC(CPSSound_deleteElement)
 434         if (_GainScheme && _GainScheme->hasMemory()) _GainScheme->deleteElement(index);
 435         if (_PitchScheme && _PitchScheme->hasMemory()) _PitchScheme->deleteElement(index);
 436         if (_Sounds[index])
 437         {
 438                 _Sounds[index]->setLooping(false);
 439                 _Sounds[index]->release();
 440         }
 441         _Sounds.remove(index);
 442 }
 443
 444 // ***************************************************************************************************
 445 void    CPSSound::resize(uint32 size)
 446 {
 447         NL_PS_FUNC(CPSSound_resize)
 448         nlassert(size < (1 << 16));
 449         if (_GainScheme && _GainScheme->hasMemory()) _GainScheme->resize(size, getOwner()->getSize());
 450         if (_PitchScheme && _PitchScheme->hasMemory()) _PitchScheme->resize(size, getOwner()->getSize());
 451         if (size < _Sounds.getSize())
 452         {
 453                 // if vector size has been shrunk, must delete sounds instances
 454                 for(uint k = size; k < _Sounds.getSize(); ++k)
 455                 {
 456                         if (_Sounds[k])
 457                         {
 458                                 _Sounds[k]->setLooping(false);
 459                                 _Sounds[k]->release();
 460                         }
 461                 }
 462         }
 463         _Sounds.resize(size);
 464 }
 465
 466 // ***************************************************************************************************
 467 void    CPSSound::setUseOriginalPitchFlag(bool useOriginalPitch)
 468 {
 469         NL_PS_FUNC(CPSSound_setUseOriginalPitchFlag)
 470         if (_PitchScheme)
 471         {
 472                 delete _PitchScheme;
 473                 _PitchScheme = NULL;
 474         }
 475         _UseOriginalPitch = useOriginalPitch;
 476 }
 477
 478
 479 } // NL3D