nel/src/sound/sound_anim_manager.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdsound.h"
  18 #include "nel/sound/sound_anim_manager.h"
  19 #include "nel/sound/sound_animation.h"
  20 //#include "nel/sound/sound_anim_player.h"
  21 #include "nel/misc/common.h"
  22 #include "nel/misc/path.h"
  23
  24 using namespace std;
  25 using namespace NLSOUND;
  26 using namespace NLMISC;
  27
  28 namespace NLSOUND {
  29
  30 CSoundAnimManager*      CSoundAnimManager::_Instance = 0;
  31
  32 // ********************************************************
  33
  34 CSoundAnimManager::CSoundAnimManager(NLSOUND::UAudioMixer* mixer) : _Mixer(mixer)
  35 {
  36         if (_Instance != 0)
  37         {
  38                 throw Exception("Duplicate instanciation of CSoundAnimManager singleton");
  39         }
  40
  41         _Instance = this;
  42         //_PlayerId = 0;
  43 }
  44
  45 // ********************************************************
  46
  47 CSoundAnimManager::~CSoundAnimManager()
  48 {
  49         if (_Instance == NULL)
  50                 return;
  51         /*
  52         set<CSoundAnimPlayer*>::iterator iter;
  53
  54         for (iter = _Players.begin(); iter != _Players.end(); iter++)
  55         {
  56                 CSoundAnimPlayer* player = *iter;
  57                 delete player;
  58         }
  59
  60         _Players.clear();
  61         */
  62
  63         _Instance = NULL;
  64 }
  65
  66 // ********************************************************
  67
  68 TSoundAnimId CSoundAnimManager::loadAnimation(std::string& name)
  69 {
  70         nlassert(!name.empty());
  71
  72         string filename;
  73         if (name.find(".anim") != name.npos)
  74         {
  75                 filename = CFile::getFilenameWithoutExtension(name);
  76                 filename.append(".sound_anim");
  77         }
  78         else
  79         {
  80                 filename = name;
  81                 filename.append(".sound_anim");
  82         }
  83
  84         // throws exception if file not found
  85         filename = CPath::lookup(filename, false, false, true);
  86         if (filename.empty())
  87         {
  88                 return CSoundAnimationNoId;
  89         }
  90
  91         TSoundAnimId id = createAnimation(name);
  92         if (id == CSoundAnimationNoId)
  93         {
  94                 return CSoundAnimationNoId;
  95         }
  96
  97         CSoundAnimation* anim = _Animations[id];
  98
  99         if (anim == NULL)
 100                 return CSoundAnimationNoId;
 101
 102         anim->setFilename(filename);
 103         anim->load();
 104
 105         return id;
 106 }
 107
 108 // ********************************************************
 109
 110 TSoundAnimId CSoundAnimManager::createAnimation(std::string& name)
 111 {
 112         nlassert(!name.empty());
 113
 114         // create and insert animations
 115         TSoundAnimId id = (TSoundAnimId)_Animations.size();
 116         CSoundAnimation* anim = new CSoundAnimation(name, id);
 117         _Animations.push_back(anim);
 118
 119         // insert the name and id in the id table
 120         pair<TSoundAnimMap::iterator, bool> inserted;
 121         inserted =_IdMap.insert(make_pair(anim->getName().c_str(), id));
 122         if (!inserted.second)
 123         {
 124                 nlwarning("Duplicate sound animation \"%s\"", name.c_str());
 125                 delete anim;
 126                 return CSoundAnimationNoId;
 127         }
 128
 129         return id;
 130 }
 131
 132 // ********************************************************
 133
 134 CSoundAnimation* CSoundAnimManager::findAnimation(std::string& name)
 135 {
 136         TSoundAnimMap::iterator iter = _IdMap.find(name.c_str());
 137         return (iter == _IdMap.end())? 0 : _Animations[(*iter).second];
 138 }
 139
 140 // ********************************************************
 141
 142 TSoundAnimId CSoundAnimManager::getAnimationFromName(std::string& name)
 143 {
 144         TSoundAnimMap::iterator iter = _IdMap.find(name.c_str());
 145         return (iter == _IdMap.end())? CSoundAnimationNoId : (*iter).second;
 146 }
 147
 148 // ********************************************************
 149
 150 void CSoundAnimManager::saveAnimation(CSoundAnimation* anim, std::string& filename)
 151 {
 152         nlassert(anim);
 153         nlassert(!filename.empty());
 154
 155         anim->setFilename(filename);
 156         anim->save ();
 157 }
 158
 159 // ********************************************************
 160 /*
 161 TSoundAnimPlayId CSoundAnimManager::playAnimation(TSoundAnimId id, float time, CVector* position)
 162 {
 163         nlassert(id != CSoundAnimationNoId);
 164         nlassert((uint32) id < _Animations.size());
 165         nlassert(position);
 166
 167         CSoundAnimation* anim = _Animations[id];
 168         nlassert(anim);
 169
 170
 171         _PlayerId++;
 172         CSoundAnimPlayer* player = new CSoundAnimPlayer(anim, time, position, _Mixer, _PlayerId);
 173         nlassert(player);
 174
 175         _Players.insert(player);
 176
 177         return _PlayerId;
 178 }
 179 */
 180
 181 struct TFindId : std::unary_function<TSoundAnimMap::value_type, bool>
 182 {
 183         TSoundAnimId    Id;
 184
 185         TFindId(TSoundAnimId id)
 186                 : Id(id)
 187         {}
 188
 189         bool operator () (const TSoundAnimMap::value_type &value) const
 190         {
 191                 return value.second == Id;
 192         }
 193 };
 194
 195 std::string     CSoundAnimManager::idToName(TSoundAnimId id)
 196 {
 197         static string empty;
 198         TSoundAnimMap::iterator it(std::find_if(_IdMap.begin(), _IdMap.end(), TFindId(id)));
 199
 200         if (it != _IdMap.end())
 201                 return it->first;
 202         else
 203                 return empty;
 204 }
 205
 206
 207 void CSoundAnimManager::playAnimation(TSoundAnimId id, float lastTime, float curTime, NL3D::CCluster *cluster, CSoundContext &context)
 208 {
 209         //nlassert(id != CSoundAnimationNoId);
 210         if (id == CSoundAnimationNoId)
 211         {
 212                 return;
 213         }
 214
 215         if ((uint32) id >= _Animations.size())
 216                 return;
 217         nlassert((uint32) id < _Animations.size());
 218
 219         CSoundAnimation* anim = _Animations[id];
 220         nlassert(anim);
 221
 222         anim->play(_Mixer, lastTime, curTime, cluster, context);
 223 }
 224
 225
 226 // ********************************************************
 227 TSoundAnimPlayId                CSoundAnimManager::playAnimation(TSoundAnimId /* id */, float /* time */, NL3D::CCluster * /* cluster */, CSoundContext &/* context */)
 228 {
 229         return 0;
 230 }
 231
 232 // ********************************************************
 233 TSoundAnimPlayId CSoundAnimManager::playAnimation(string& /* name */, float /* time */, NL3D::CCluster * /* cluster */, CSoundContext &/* context */)
 234 {
 235 /*      nlassert(position);
 236
 237         TSoundAnimId id = getAnimationFromName(name);
 238         return (id == CSoundAnimation::NoId)? -1 : _PlayerId;*/
 239         return 0;
 240 }
 241
 242
 243 // ********************************************************
 244 void CSoundAnimManager::stopAnimation(TSoundAnimPlayId /* playbackId */)
 245 {
 246 /*      nlassert(playbackId >= 0);
 247
 248         set<CSoundAnimPlayer*>::iterator iter;
 249
 250         for (iter = _Players.begin(); iter != _Players.end(); )
 251         {
 252                 CSoundAnimPlayer* player = *iter;
 253                 if (player->getId() == playbackId)
 254                 {
 255                         _Players.erase(iter);
 256                         break;
 257                 }
 258         }*/
 259 }
 260
 261 // ********************************************************
 262 bool CSoundAnimManager::isPlaying(TSoundAnimPlayId /* playbackId */)
 263 {
 264         /*nlassert(playbackId >= 0);
 265
 266         set<CSoundAnimPlayer*>::iterator iter;
 267
 268         for (iter = _Players.begin(); iter != _Players.end(); )
 269         {
 270                 CSoundAnimPlayer* player = *iter;
 271                 if (player->getId() == playbackId)
 272                 {
 273                         return player->isPlaying();
 274                 }
 275         }*/
 276
 277         return false;
 278 }
 279
 280 // ********************************************************
 281 void CSoundAnimManager::update(float /* lastTime */, float /* curTime */)
 282 {
 283 /*      set<CSoundAnimPlayer*>::iterator iter;
 284
 285         _Garbage.clear();
 286
 287         for (iter = _Players.begin(); iter != _Players.end(); iter++)
 288         {
 289                 CSoundAnimPlayer* player = *iter;
 290                 if (player->isPlaying())
 291                 {
 292                         player->update(lastTime, curTime);
 293                 }
 294                 else
 295                 {
 296                         _Garbage.push_back(player);
 297                 }
 298         }
 299
 300         vector<CSoundAnimPlayer*>::iterator iter2;
 301
 302         for (iter2 = _Garbage.begin(); iter2 != _Garbage.end(); iter2++)
 303         {
 304                 iter = _Players.find(*iter2);
 305                 if (iter != _Players.end())
 306                 {
 307                         _Players.erase(iter);
 308                 }
 309         }*/
 310 }
 311
 312
 313 } // namespace NLSOUND
 314
 315