nel/src/sound/context_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) 2010  Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
   6 // Copyright (C) 2019  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 #include "stdsound.h"
  22
  23 #include "nel/sound/context_sound.h"
  24 #include "nel/sound/sound_bank.h"
  25
  26 using namespace std;
  27 using namespace NLMISC;
  28
  29
  30
  31 namespace NLSOUND {
  32
  33
  34 //CContextSound test;
  35
  36
  37 /// Constructor
  38 CContextSound::CContextSound()
  39 :       _ContextSounds(0)
  40 {
  41 }
  42 /// Destructor
  43 CContextSound::~CContextSound()
  44 {
  45         if (_ContextSounds != 0)
  46                 delete _ContextSounds;
  47 }
  48
  49 void            CContextSound::serial(NLMISC::IStream &s)
  50 {
  51         CSound::serial(s);
  52         s.serial(_PatternName);
  53
  54         if (s.isReading())
  55         {
  56                 if (_ContextSounds)
  57                         delete _ContextSounds;
  58         }
  59 }
  60
  61
  62 /// Load the sound parameters from georges' form
  63 void            CContextSound::importForm(const std::string& filename, NLGEORGES::UFormElm& formRoot)
  64 {
  65         NLGEORGES::UFormElm *psoundType;
  66         std::string dfnName;
  67
  68         // some basic checking.
  69         formRoot.getNodeByName(&psoundType, ".SoundType");
  70         nlassert(psoundType != NULL);
  71         psoundType->getDfnName(dfnName);
  72         nlassert(dfnName == "context_sound.dfn");
  73
  74         // Call the base class
  75         CSound::importForm(filename, formRoot);
  76
  77         // Read the pattern name
  78         formRoot.getValueByName(_PatternName, ".SoundType.PatternName");
  79 }
  80
  81 /// Return true if cone is meaningful
  82 bool            CContextSound::isDetailed() const
  83 {
  84         return false;
  85 }
  86
  87 float           CContextSound::getMaxDistance() const
  88 {
  89         if (_ContextSounds == 0)
  90         {
  91                 const_cast<CContextSound*>(this)->init();
  92                 if (_ContextSounds == 0)
  93                 {
  94                         // invalid state
  95                         return 0;
  96                 }
  97         }
  98         return _ContextSounds->getMaxDistance();;
  99 }
 100
 101 /// Return the length of the sound in ms
 102 uint32          CContextSound::getDuration()
 103 {
 104         std::vector<std::pair<std::string, CSound*> > sounds;
 105         getSubSoundList(sounds);
 106
 107         uint32 duration = 0;
 108
 109         std::vector<std::pair<std::string, CSound*> >::iterator first(sounds.begin()), last(sounds.end());
 110         for (; first != last; ++first)
 111         {
 112                 duration = std::max(duration, first->second->getDuration());
 113         }
 114         return duration;
 115 }
 116
 117 /// Used by the george sound plugin to check sound recursion (ie sound 'toto' use sound 'titi' witch also use sound 'toto' ...).
 118 void            CContextSound::getSubSoundList(std::vector<std::pair<std::string, CSound*> > &subsounds) const
 119 {
 120         if (_ContextSounds == 0)
 121         {
 122                 const_cast<CContextSound*>(this)->init();
 123         }
 124
 125         if (_ContextSounds)
 126         {
 127                 _ContextSounds->getSoundList(subsounds);
 128         }
 129 }
 130
 131 CSound  *CContextSound::getContextSound(CSoundContext &context)
 132 {
 133         if (_ContextSounds == 0)
 134         {
 135                 // need to init the sound container.
 136                 init();
 137
 138                 if (_ContextSounds == 0)
 139                         return 0;
 140         }
 141
 142         if (_Random > 1)
 143         {
 144                 // compute the random value.
 145                 uint32  r;
 146                 do
 147                 {
 148                         r = rand()%_Random;
 149                 } while (r == context.PreviousRandom);
 150
 151                 context.PreviousRandom = r;
 152
 153                 return _ContextSounds->getSound(context, r);
 154         }
 155         else
 156                 return _ContextSounds->getSound(context, 0);
 157
 158
 159 }
 160
 161 void CContextSound::init()
 162 {
 163         uint    nbJoker = 0;
 164         uint    contextArgIndex[SoundContextNbArgs];
 165         bool    useRandom = false;
 166         bool    parseArg = false;
 167         _BaseName.clear();
 168
 169         //nldebug("Init the context sound %s", _PatternName.c_str());
 170
 171         string::iterator        first(_PatternName.begin()), last(_PatternName.end());
 172         // 1st loop until the first joker
 173         for(; first != last && *first != '%'; ++first)
 174                 _BaseName += *first;
 175
 176         // 2nd loop, now we read the context arg index for each joker.
 177         std::string index;
 178         for (; first != last; ++first)
 179         {
 180                 if (parseArg)
 181                 {
 182                         if (isdigit(int(*first)))
 183                         {
 184                                 index += *first;
 185                         }
 186                         else if (!index.empty())
 187                         {
 188                                 if (useRandom)
 189                                 {
 190                                         fromString(index, _Random);
 191                                 }
 192                                 else
 193                                 {
 194                                         nlassertex(nbJoker < SoundContextNbArgs, ("Error will trying to play ContextSound '%s'", CStringMapper::unmap(_Name).c_str()));
 195                                         fromString(index, contextArgIndex[nbJoker++]);
 196                                         parseArg = false;
 197                                         index.clear();
 198                                 }
 199                         }
 200                         else if (*first == 'r')
 201                         {
 202                                 nlassertex(useRandom == false, ("Error will trying to play ContextSound '%s'", CStringMapper::unmap(_Name).c_str()));
 203                                 useRandom = true;
 204                         }
 205                 }
 206                 else if (*first == '%')
 207                 {
 208                         nlassertex(useRandom == false, ("Error will trying to play ContextSound '%s'", CStringMapper::unmap(_Name).c_str()));
 209                         parseArg = true;
 210                 }
 211         }
 212
 213         // read the last char...
 214         if (!index.empty())
 215         {
 216                 if (useRandom)
 217                 {
 218                         fromString(index, _Random);
 219                 }
 220                 else
 221                 {
 222                         nlassertex(nbJoker < SoundContextNbArgs, ("Error will trying to play ContextSound '%s'", CStringMapper::unmap(_Name).c_str()));
 223                         fromString(index, contextArgIndex[nbJoker++]);
 224                         parseArg = false;
 225                 }
 226         }
 227
 228         if (_ContextSounds != 0)
 229                 delete _ContextSounds;
 230
 231         // A little macro to make life easier (LM stand for Local Macro)
 232 #define LM_CASE_CONTAINER_CREATOR(size) case (size):\
 233                                                                                         if (useRandom)\
 234                                                                                                 _ContextSounds = new CContextSoundContainer<(size), true>;\
 235                                                                                         else\
 236                                                                                                 _ContextSounds = new CContextSoundContainer<(size), false>;\
 237                                                                                         break;
 238
 239         // ok, now instantiate the correct container
 240         switch (nbJoker)
 241         {
 242                 LM_CASE_CONTAINER_CREATOR(0)
 243                 LM_CASE_CONTAINER_CREATOR(1)
 244                 LM_CASE_CONTAINER_CREATOR(2)
 245                 LM_CASE_CONTAINER_CREATOR(3)
 246                 LM_CASE_CONTAINER_CREATOR(4)
 247                 LM_CASE_CONTAINER_CREATOR(5)
 248                 LM_CASE_CONTAINER_CREATOR(6)
 249                 LM_CASE_CONTAINER_CREATOR(7)
 250                 LM_CASE_CONTAINER_CREATOR(8)
 251                 LM_CASE_CONTAINER_CREATOR(9)
 252                 LM_CASE_CONTAINER_CREATOR(10)
 253         default:
 254                 nlwarning("Unsuported number of context argument in context sound '%s'!", CStringMapper::unmap(_Name).c_str());
 255                 return;
 256         }
 257         // cleanup macro
 258 #undef LM_CASE_CONTAINER_CREATOR
 259
 260         _ContextSounds->init(contextArgIndex);
 261
 262         // ok, we have the container, now fill it with the sound
 263         {
 264                 std::vector<NLMISC::TStringId> allSounds;
 265 //              CSoundBank::getSoundNames(allSounds);
 266                 CAudioMixerUser::instance()->getSoundNames(allSounds);
 267
 268                 std::vector<NLMISC::TStringId>::iterator first(allSounds.begin()), last(allSounds.end());
 269                 for (; first != last; ++first)
 270                 {
 271                         const std::string &soundName = CStringMapper::unmap(*first);
 272                         if (soundName.size() > _BaseName.size())
 273                         {
 274                                 uint i;
 275                                 for (i=0; i<_BaseName.size(); ++i)
 276                                 {
 277                                         if (soundName[i] != _BaseName[i])
 278                                                 break;
 279                                 }
 280                                 if (i == _BaseName.size())
 281                                 {
 282                                         // The base name is ok, check that the next char is a digit (avoid conflit if some
 283                                         // sound have a longeur base name with same beginning)
 284                                         if (soundName[i] >= '0' && soundName[i] <= '9')
 285                                                 _ContextSounds->addSound(CAudioMixerUser::instance()->getSoundId(*first), _BaseName);
 286                                 }
 287                         }
 288                 }
 289         }
 290 }
 291
 292
 293
 294 } // NLSOUND