Let all SFX commands be handled by the sfx manager thread (otherwise

events could be handled in the wrong order, e.g. a delete from the
main thread before the play in the manager thread, resulting in a crash).
Should fix #1511 and #1604.

src/audio/dummy_sfx.hpp

@@ -40,9 +40,14 @@ public:
     virtual void       position(const Vec3 &position) {}
     virtual void       setLoop(bool status)           {}
     virtual void       play()                         {}
+    virtual void       reallyPlayNow()                {}
     virtual void       stop()                         {}
+    virtual void       reallyStopNow()                {}
     virtual void       pause()                        {}
+    virtual void       reallyPauseNow()               {}
     virtual void       resume()                       {}
+    virtual void       reallyResumeNow()              {}
+    virtual void       deleteSFX()                    { delete this; }
     virtual void       speed(float factor)            {}
     virtual void       volume(float gain)             {}
     virtual SFXManager::SFXStatus  getStatus()        { return SFXManager::SFX_STOPPED; }

src/audio/sfx_base.hpp

@@ -52,8 +52,12 @@ public:
     virtual void       play()                         = 0;
     virtual void       reallyPlayNow()                = 0;
     virtual void       stop()                         = 0;
+    virtual void       reallyStopNow()                = 0;
     virtual void       pause()                        = 0;
+    virtual void       reallyPauseNow()               = 0;
     virtual void       resume()                       = 0;
+    virtual void       reallyResumeNow()              = 0;
+    virtual void       deleteSFX()                    = 0;
     virtual void       speed(float factor)            = 0;
     virtual void       volume(float gain)             = 0;
     virtual void       setMasterVolume(float gain)    = 0;

src/audio/sfx_manager.cpp

@@ -124,13 +124,15 @@ SFXManager::~SFXManager()
     pthread_cond_destroy(&m_cond_request);
 
     // ---- clear m_all_sfx
-    const int sfx_amount = (int) m_all_sfx.size();
+    // not strictly necessary, but might avoid copy&paste problems
+    m_all_sfx.lock();
+    const int sfx_amount = (int) m_all_sfx.getData().size();
     for (int n=0; n<sfx_amount; n++)
     {
-        delete m_all_sfx[n];
+        delete m_all_sfx.getData()[n];
     }
-    m_all_sfx.clear();
+    m_all_sfx.getData().clear();
-
+    m_all_sfx.unlock();
     // ---- clear m_quick_sounds
     {
         std::map<std::string, SFXBase*>::iterator i = m_quick_sounds.begin();
@@ -227,6 +229,14 @@ void* SFXManager::mainLoop(void *obj)
         switch(current->m_command)
         {
         case SFX_PLAY:   current->m_sfx->reallyPlayNow();   break;
+        case SFX_STOP:   current->m_sfx->reallyStopNow();   break;
+        case SFX_PAUSE:  current->m_sfx->reallyPauseNow();  break;
+        case SFX_RESUME: current->m_sfx->reallyResumeNow(); break;
+        case SFX_DELETE: {
+                            current->m_sfx->reallyStopNow();
+                            me->deleteSFX(current->m_sfx);
+                            break;
+                         }
         default: assert("Not yet supported.");
         }
         delete current;
@@ -262,12 +272,13 @@ void SFXManager::soundToggled(const bool on)
         }
 
         resumeAll();
-
+        m_all_sfx.lock();
-        const int sfx_amount = (int)m_all_sfx.size();
+        const int sfx_amount = (int)m_all_sfx.getData().size();
         for (int n=0; n<sfx_amount; n++)
         {
-            m_all_sfx[n]->onSoundEnabledBack();
+            m_all_sfx.getData()[n]->onSoundEnabledBack();
         }
+        m_all_sfx.unlock();
     }
     else
     {
@@ -451,7 +462,14 @@ SFXBase* SFXManager::createSoundSource(SFXBuffer* buffer,
 
     sfx->setMasterVolume(m_master_gain);
 
-    if (add_to_SFX_list) m_all_sfx.push_back(sfx);
+    if (add_to_SFX_list) 
+    {
+        m_all_sfx.lock();
+        m_all_sfx.getData().push_back(sfx);
+        m_all_sfx.unlock();
+    }
+    else
+        printf("");
 
     return sfx;
 }   // createSoundSource
@@ -511,21 +529,26 @@ void SFXManager::deleteSFXMapping(const std::string &name)
  */
 void SFXManager::deleteSFX(SFXBase *sfx)
 {
-    if(sfx) sfx->stop();
+    if(sfx) sfx->reallyStopNow();
     std::vector<SFXBase*>::iterator i;
-    i=std::find(m_all_sfx.begin(), m_all_sfx.end(), sfx);
     
-    if(i==m_all_sfx.end())
+    // The whole block needs to be locked, otherwise the iterator
+    // could become invalid.
+    m_all_sfx.lock();
+    i=std::find(m_all_sfx.getData().begin(), m_all_sfx.getData().end(), sfx);
+
+    if(i==m_all_sfx.getData().end())
     {
         Log::warn("SFXManager", 
-                  "SFXManager::deleteSFX : Warning: sfx not found in list.");
+                  "SFXManager::deleteSFX : Warning: sfx '%s' %lx not found in list.",
+                  sfx->getBuffer()->getFileName().c_str(), sfx);
         return;
     }
 
+    m_all_sfx.getData().erase(i);
     delete sfx;
 
-    m_all_sfx.erase(i);
+    m_all_sfx.unlock();
-
 }   // deleteSFX
 
 //----------------------------------------------------------------------------
@@ -535,11 +558,13 @@ void SFXManager::deleteSFX(SFXBase *sfx)
  */
 void SFXManager::pauseAll()
 {
-    for (std::vector<SFXBase*>::iterator i=m_all_sfx.begin();
+    m_all_sfx.lock();
-        i!=m_all_sfx.end(); i++)
+    for (std::vector<SFXBase*>::iterator i= m_all_sfx.getData().begin();
+                                         i!=m_all_sfx.getData().end(); i++)
     {
         (*i)->pause();
     }   // for i in m_all_sfx
+    m_all_sfx.unlock();
 }   // pauseAll
 
 //----------------------------------------------------------------------------
@@ -551,13 +576,15 @@ void SFXManager::resumeAll()
     // ignore unpausing if sound is disabled
     if (!sfxAllowed()) return;
 
-    for (std::vector<SFXBase*>::iterator i=m_all_sfx.begin();
+    m_all_sfx.lock();
-        i!=m_all_sfx.end(); i++)
+    for (std::vector<SFXBase*>::iterator i =m_all_sfx.getData().begin();
+                                         i!=m_all_sfx.getData().end(); i++)
     {
         SFXStatus status = (*i)->getStatus();
         // Initial happens when
         if (status==SFX_PAUSED) (*i)->resume();
     }   // for i in m_all_sfx
+    m_all_sfx.unlock();
 }   // resumeAll
 
 //-----------------------------------------------------------------------------
@@ -594,11 +621,13 @@ void SFXManager::setMasterSFXVolume(float gain)
 
     // regular SFX
     {
-        for (std::vector<SFXBase*>::iterator i=m_all_sfx.begin();
+        m_all_sfx.lock();
-            i!=m_all_sfx.end(); i++)
+        for (std::vector<SFXBase*>::iterator i =m_all_sfx.getData().begin();
+                                             i!=m_all_sfx.getData().end(); i++)
         {
             (*i)->setMasterVolume(m_master_gain);
         }   // for i in m_all_sfx
+        m_all_sfx.unlock();
     }
 
     // quick SFX

src/audio/sfx_manager.hpp

@@ -122,7 +122,7 @@ private:
     std::map<std::string, SFXBuffer*> m_all_sfx_types;
 
     /** The actual instances (sound sources) */
-    std::vector<SFXBase*> m_all_sfx;
+    Synchronised<std::vector<SFXBase*> > m_all_sfx;
 
     /** The list of sound effects to be played in the next update. */
     Synchronised< std::vector<SFXCommand*> > m_sfx_commands;
@@ -150,6 +150,7 @@ private:
     virtual                 ~SFXManager();
 
     static void* mainLoop(void *obj);
+    void deleteSFX(SFXBase *sfx);
 public:
     static void create();
     static void destroy();
@@ -182,7 +183,6 @@ public:
     SFXBase*                 createSoundSource(const std::string &name,
                                                const bool addToSFXList=true);
 
-    void                     deleteSFX(SFXBase *sfx);
     void                     deleteSFXMapping(const std::string &name);
     void                     pauseAll();
     void                     resumeAll();

src/audio/sfx_openal.cpp

@@ -182,9 +182,16 @@ void SFXOpenAL::setLoop(bool status)
 }   // loop
 
 //-----------------------------------------------------------------------------
-/** Stops playing this sound effect.
+/** Queues a stop for this effect to the sound manager.
  */
 void SFXOpenAL::stop()
+{
+    SFXManager::get()->queue(SFXManager::SFX_STOP, this);
+}   // stop
+//-----------------------------------------------------------------------------
+/** The sfx manager thread executes a stop for this sfx.
+ */
+void SFXOpenAL::reallyStopNow()
 {
     if(!m_ok) return;
 
@@ -193,23 +200,39 @@ void SFXOpenAL::stop()
     alSourcei(m_soundSource, AL_LOOPING, AL_FALSE);
     alSourceStop(m_soundSource);
     SFXManager::checkError("stoping");
-}   // stop
+}   // reallyStopNow
+
+//-----------------------------------------------------------------------------
+/** Queues up a pause command for this sfx.
+ */
+void SFXOpenAL::pause()
+{
+    SFXManager::get()->queue(SFXManager::SFX_PAUSE, this);
+}   // pause
 
 //-----------------------------------------------------------------------------
 /** Pauses a SFX that's currently played. Nothing happens it the effect is
  *  currently not being played.
  */
-void SFXOpenAL::pause()
+void SFXOpenAL::reallyPauseNow()
 {
     if(!m_ok) return;
     alSourcePause(m_soundSource);
     SFXManager::checkError("pausing");
-}   // pause
+}   // reallyPauseNow
+
+//-----------------------------------------------------------------------------
+/** Queues up a resume command for this sound effect.
+ */
+void SFXOpenAL::resume()
+{
+    SFXManager::get()->queue(SFXManager::SFX_RESUME, this);
+}   // resume
 
 //-----------------------------------------------------------------------------
 /** Resumes a sound effect.
  */
-void SFXOpenAL::resume()
+void SFXOpenAL::reallyResumeNow()
 {
     if (!m_ok)
     {
@@ -222,7 +245,17 @@ void SFXOpenAL::resume()
 
     alSourcePlay(m_soundSource);
     SFXManager::checkError("resuming");
-}   // resume
+}   // reallyResumeNow
+
+//-----------------------------------------------------------------------------
+/** Queues up a delete request for this object. This is necessary to avoid
+ *  a crash if the sfx manager thread might be delayed and access this object
+ *  after it was deleted.
+ */
+void SFXOpenAL::deleteSFX()
+{
+    SFXManager::get()->queue(SFXManager::SFX_DELETE, this);
+}   // deleteSFX
 
 //-----------------------------------------------------------------------------
 /** This actually queues up the sfx in the sfx manager. It will be started

src/audio/sfx_openal.hpp

@@ -77,8 +77,12 @@ public:
     virtual void                  setLoop(bool status);
     virtual bool                  isPlaying();
     virtual void                  stop();
+    virtual void                  reallyStopNow();
     virtual void                  pause();
+    virtual void                  reallyPauseNow();
     virtual void                  resume();
+    virtual void                  reallyResumeNow();
+    virtual void                  deleteSFX();
     virtual void                  speed(float factor);
     virtual void                  position(const Vec3 &position);
     virtual void                  volume(float gain);

src/graphics/hit_sfx.cpp

@@ -42,10 +42,7 @@ HitSFX::HitSFX(const Vec3& coord, const char* explosion_sound)
  */
 HitSFX::~HitSFX()
 {
-    if (m_sfx->getStatus() == SFXManager::SFX_PLAYING)
+    m_sfx->deleteSFX();
-        m_sfx->stop();
-
-    SFXManager::get()->deleteSFX(m_sfx);
 }   // ~HitEffect
 
 //-----------------------------------------------------------------------------

src/graphics/weather.cpp

@@ -51,11 +51,11 @@ Weather::Weather(bool lightning, std::string sound)
 Weather::~Weather()
 {
     if (m_thunder_sound != NULL) 
-        SFXManager::get()->deleteSFX(m_thunder_sound);
+        m_thunder_sound->deleteSFX();
         
     if (m_weather_sound != NULL) 
-        SFXManager::get()->deleteSFX(m_weather_sound);
+        m_weather_sound->deleteSFX();
-}
+}   // ~Weather
 
 // ----------------------------------------------------------------------------
 

src/items/attachment.cpp

@@ -80,13 +80,13 @@ Attachment::~Attachment()
 
     if (m_bomb_sound)
     {
-        SFXManager::get()->deleteSFX(m_bomb_sound);
+        m_bomb_sound->deleteSFX();
         m_bomb_sound = NULL;
     }
     
     if (m_bubble_explode_sound)
     {
-        SFXManager::get()->deleteSFX(m_bubble_explode_sound);
+        m_bubble_explode_sound->deleteSFX();
         m_bubble_explode_sound = NULL;
     }
 }   // ~Attachment
@@ -139,7 +139,7 @@ void Attachment::set(AttachmentType type, float time,
         break;
     case ATTACH_BOMB:
         m_node->setMesh(attachment_manager->getMesh(type));
-        if (m_bomb_sound) SFXManager::get()->deleteSFX(m_bomb_sound);
+        if (m_bomb_sound) m_bomb_sound->deleteSFX();
         m_bomb_sound = SFXManager::get()->createSoundSource("clock");
         m_bomb_sound->setLoop(true);
         m_bomb_sound->position(m_kart->getXYZ());
@@ -198,8 +198,7 @@ void Attachment::clear()
 
     if (m_bomb_sound)
     {
-        m_bomb_sound->stop();
+        m_bomb_sound->deleteSFX();
-        SFXManager::get()->deleteSFX(m_bomb_sound);
         m_bomb_sound = NULL;
     }
 
@@ -460,8 +459,7 @@ void Attachment::update(float dt)
 
             if (m_bomb_sound)
             {
-                m_bomb_sound->stop();
+                m_bomb_sound->deleteSFX();
-                SFXManager::get()->deleteSFX(m_bomb_sound);
                 m_bomb_sound = NULL;
             }
         }
@@ -474,7 +472,7 @@ void Attachment::update(float dt)
         if (m_time_left < 0)
         {
             m_time_left = 0.0f;
-            if (m_bubble_explode_sound) SFXManager::get()->deleteSFX(m_bubble_explode_sound);
+            if (m_bubble_explode_sound) m_bubble_explode_sound->deleteSFX();
             m_bubble_explode_sound = SFXManager::get()->createSoundSource("bubblegum_explode");
             m_bubble_explode_sound->position(m_kart->getXYZ());
             m_bubble_explode_sound->play();

src/items/bowling.cpp

@@ -87,9 +87,9 @@ Bowling::Bowling(AbstractKart *kart)
  */
 Bowling::~Bowling()
 {
-    if(m_roll_sfx->getStatus()==SFXManager::SFX_PLAYING)
+    // This will stop the sfx and delete the object.
-        m_roll_sfx->stop();
+    m_roll_sfx->deleteSFX();
-    SFXManager::get()->deleteSFX(m_roll_sfx);
+
 }   // ~RubberBall
 
 // -----------------------------------------------------------------------------

src/items/powerup.cpp

@@ -53,7 +53,7 @@ Powerup::Powerup(AbstractKart* kart)
  */
 Powerup::~Powerup()
 {
-    if(m_sound_use) SFXManager::get()->deleteSFX(m_sound_use);
+    if(m_sound_use) m_sound_use->deleteSFX();
 }   // ~Powerup
 
 //-----------------------------------------------------------------------------
@@ -88,7 +88,7 @@ void Powerup::set(PowerupManager::PowerupType type, int n)
 
     if(m_sound_use != NULL)
     {
-        SFXManager::get()->deleteSFX(m_sound_use);
+        m_sound_use->deleteSFX();
         m_sound_use = NULL;
     }
 

src/items/rubber_ball.cpp

@@ -109,7 +109,7 @@ RubberBall::~RubberBall()
 {
     if(m_ping_sfx->getStatus()==SFXManager::SFX_PLAYING)
         m_ping_sfx->stop();
-    SFXManager::get()->deleteSFX(m_ping_sfx);
+    m_ping_sfx->deleteSFX();
 }   // ~RubberBall
 
 // ----------------------------------------------------------------------------

src/items/swatter.cpp

@@ -100,7 +100,7 @@ Swatter::~Swatter()
     }
     if (m_swat_sound)
     {
-        SFXManager::get()->deleteSFX(m_swat_sound);
+        m_swat_sound->deleteSFX();
     }
 }   // ~Swatter
 

src/karts/controller/player_controller.cpp

@@ -74,11 +74,11 @@ PlayerController::PlayerController(AbstractKart *kart,
  */
 PlayerController::~PlayerController()
 {
-    SFXManager::get()->deleteSFX(m_bzzt_sound);
+    m_bzzt_sound->deleteSFX();
-    SFXManager::get()->deleteSFX(m_wee_sound );
+    m_wee_sound ->deleteSFX();
-    SFXManager::get()->deleteSFX(m_ugh_sound );
+    m_ugh_sound ->deleteSFX();
-    SFXManager::get()->deleteSFX(m_grab_sound);
+    m_grab_sound->deleteSFX();
-    SFXManager::get()->deleteSFX(m_full_sound);
+    m_full_sound->deleteSFX();
 }   // ~PlayerController
 
 //-----------------------------------------------------------------------------

src/karts/kart.cpp

@@ -246,15 +246,15 @@ Kart::~Kart()
             SFXManager::get()->deleteSFX(m_custom_sounds[n]);
     }*/
 
-    SFXManager::get()->deleteSFX(m_engine_sound );
+    m_engine_sound->deleteSFX();
-    SFXManager::get()->deleteSFX(m_crash_sound  );
+    m_crash_sound ->deleteSFX();
-    SFXManager::get()->deleteSFX(m_skid_sound   );
+    m_skid_sound  ->deleteSFX();
-    SFXManager::get()->deleteSFX(m_goo_sound    );
+    m_goo_sound   ->deleteSFX();
-    SFXManager::get()->deleteSFX(m_beep_sound   );
+    m_beep_sound  ->deleteSFX();
-    SFXManager::get()->deleteSFX(m_boing_sound  );
+    m_boing_sound ->deleteSFX();
     delete m_kart_gfx;
-    if(m_terrain_sound)          SFXManager::get()->deleteSFX(m_terrain_sound);
+    if(m_terrain_sound)          m_terrain_sound->deleteSFX();
-    if(m_previous_terrain_sound) SFXManager::get()->deleteSFX(m_previous_terrain_sound);
+    if(m_previous_terrain_sound) m_previous_terrain_sound->deleteSFX();
     if(m_collision_particles)    delete m_collision_particles;
     if(m_slipstream)             delete m_slipstream;
     if(m_sky_particles_emitter)  delete m_sky_particles_emitter;
@@ -363,15 +363,14 @@ void Kart::reset()
 
     if(m_terrain_sound)
     {
-        SFXManager::get()->deleteSFX(m_terrain_sound);
+        m_terrain_sound->deleteSFX();
+        m_terrain_sound = NULL;
     }
     if(m_previous_terrain_sound)
     {
-        SFXManager::get()->deleteSFX(m_previous_terrain_sound);
+        m_previous_terrain_sound->deleteSFX();
-    }
-
-    m_terrain_sound = NULL;
         m_previous_terrain_sound = NULL;
+    }
 
     if(m_engine_sound)
         m_engine_sound->stop();
@@ -1430,7 +1429,7 @@ void Kart::handleMaterialSFX(const Material *material)
         // can be used again.
         if(m_previous_terrain_sound)
         {
-            SFXManager::get()->deleteSFX(m_previous_terrain_sound);
+            m_previous_terrain_sound->deleteSFX();
         }
         m_previous_terrain_sound = m_terrain_sound;
         if(m_previous_terrain_sound)
@@ -1467,7 +1466,7 @@ void Kart::handleMaterialSFX(const Material *material)
         // We don't modify the position of m_previous_terrain_sound
         // anymore, so that it keeps on playing at the place where the
         // kart left the material.
-        SFXManager::get()->deleteSFX(m_previous_terrain_sound);
+        m_previous_terrain_sound->deleteSFX();
         m_previous_terrain_sound = NULL;
     }
     
@@ -1592,7 +1591,7 @@ void Kart::handleMaterialGFX()
         (m_terrain_sound == NULL ||
          m_terrain_sound->getStatus() == SFXManager::SFX_STOPPED))
     {
-        if (m_previous_terrain_sound) SFXManager::get()->deleteSFX(m_previous_terrain_sound);
+        if (m_previous_terrain_sound) m_previous_terrain_sound->deleteSFX();
         m_previous_terrain_sound = m_terrain_sound;
         if(m_previous_terrain_sound)
             m_previous_terrain_sound->setLoop(false);

src/modes/linear_world.cpp

@@ -73,7 +73,7 @@ void LinearWorld::init()
  */
 LinearWorld::~LinearWorld()
 {
-    SFXManager::get()->deleteSFX(m_last_lap_sfx);
+    m_last_lap_sfx->deleteSFX();
 }   // ~LinearWorld
 
 //-----------------------------------------------------------------------------

src/modes/soccer_world.cpp

@@ -60,7 +60,7 @@ SoccerWorld::SoccerWorld() : WorldWithRank()
  */
 SoccerWorld::~SoccerWorld()
 {
-    SFXManager::get()->deleteSFX(m_goal_sound);
+    m_goal_sound->deleteSFX();
 }   // ~SoccerWorld
 
 //-----------------------------------------------------------------------------

src/modes/world_status.cpp

@@ -74,9 +74,9 @@ void WorldStatus::reset()
  */
 WorldStatus::~WorldStatus()
 {
-    SFXManager::get()->deleteSFX(m_prestart_sound);
+    m_prestart_sound->deleteSFX();
-    SFXManager::get()->deleteSFX(m_start_sound);
+    m_start_sound->deleteSFX();
-    SFXManager::get()->deleteSFX(m_track_intro_sound);
+    m_track_intro_sound->deleteSFX();
     IrrlichtDevice *device = irr_driver->getDevice();
 
     if (device->getTimer()->isStopped())  

src/tracks/track_object_presentation.cpp

@@ -382,8 +382,9 @@ void TrackObjectPresentationMesh::reset()
 // ----------------------------------------------------------------------------
 
 
-TrackObjectPresentationSound::TrackObjectPresentationSound(const XMLNode& xml_node, scene::ISceneNode* parent) :
+TrackObjectPresentationSound::TrackObjectPresentationSound(const XMLNode& xml_node,
-    TrackObjectPresentation(xml_node)
+                                                           scene::ISceneNode* parent) 
+                            : TrackObjectPresentation(xml_node)
 {
     // TODO: respect 'parent' if any
 
@@ -440,8 +441,9 @@ TrackObjectPresentationSound::TrackObjectPresentationSound(const XMLNode& xml_no
     {
         ItemManager::get()->newItem(m_init_xyz, trigger_distance, this);
     }
-}
+}   // TrackObjectPresentationSound
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationSound::update(float dt)
 {
     if (m_sound != NULL)
@@ -451,16 +453,18 @@ void TrackObjectPresentationSound::update(float dt)
         // moved
         m_sound->position(m_xyz);
     }
-}
+}   // update
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationSound::onTriggerItemApproached(Item* who)
 {
     if (m_sound != NULL && m_sound->getStatus() != SFXManager::SFX_PLAYING)
     {
         m_sound->play();
     }
-}
+}   // onTriggerItemApproached
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationSound::triggerSound(bool loop)
 {
     if (m_sound != NULL)
@@ -468,34 +472,37 @@ void TrackObjectPresentationSound::triggerSound(bool loop)
         m_sound->setLoop(loop);
         m_sound->play();
     }
-}
+}   // triggerSound
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationSound::stopSound()
 {
     if (m_sound != NULL) m_sound->stop();
-}
+}   // stopSound
 
+// ----------------------------------------------------------------------------
 TrackObjectPresentationSound::~TrackObjectPresentationSound()
 {
     if (m_sound)
     {
-        //delete m_sound->getBuffer();
+        m_sound->deleteSFX();
-        SFXManager::get()->deleteSFX(m_sound);
-    }
     }
+}   // ~TrackObjectPresentationSound
 
-void TrackObjectPresentationSound::move(const core::vector3df& xyz, const core::vector3df& hpr,
+// ----------------------------------------------------------------------------
+void TrackObjectPresentationSound::move(const core::vector3df& xyz, 
+                                        const core::vector3df& hpr,
                                         const core::vector3df& scale)
 {
     m_xyz = xyz;
     if (m_sound != NULL) m_sound->position(xyz);
-}
+}   // move
 
 // ----------------------------------------------------------------------------
 
-
+TrackObjectPresentationBillboard::TrackObjectPresentationBillboard(const XMLNode& xml_node, 
-TrackObjectPresentationBillboard::TrackObjectPresentationBillboard(const XMLNode& xml_node, scene::ISceneNode* parent) :
+                                                                   scene::ISceneNode* parent)
-    TrackObjectPresentationSceneNode(xml_node)
+                                : TrackObjectPresentationSceneNode(xml_node)
 {
     std::string texture_name;
     float       width, height;
@@ -529,6 +536,7 @@ TrackObjectPresentationBillboard::TrackObjectPresentationBillboard(const XMLNode
     m_node->setPosition(m_init_xyz);
 }
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationBillboard::update(float dt)
 {
     if (m_fade_out_when_close)
@@ -554,6 +562,7 @@ void TrackObjectPresentationBillboard::update(float dt)
     }
 }
 
+// ----------------------------------------------------------------------------
 TrackObjectPresentationBillboard::~TrackObjectPresentationBillboard()
 {
     if (m_node)
@@ -613,6 +622,7 @@ TrackObjectPresentationParticles::TrackObjectPresentationParticles(const XMLNode
     }
 }
 
+// ----------------------------------------------------------------------------
 TrackObjectPresentationParticles::~TrackObjectPresentationParticles()
 {
     if (m_emitter)
@@ -626,6 +636,7 @@ TrackObjectPresentationParticles::~TrackObjectPresentationParticles()
     }
 }
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationParticles::update(float dt)
 {
     if (m_emitter != NULL)
@@ -634,6 +645,7 @@ void TrackObjectPresentationParticles::update(float dt)
     }
 }
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationParticles::triggerParticles()
 {
     if (m_emitter != NULL)
@@ -671,6 +683,7 @@ TrackObjectPresentationLight::TrackObjectPresentationLight(const XMLNode& xml_no
     }
 }
 
+// ----------------------------------------------------------------------------
 TrackObjectPresentationLight::~TrackObjectPresentationLight()
 {
 }
@@ -693,6 +706,7 @@ TrackObjectPresentationActionTrigger::TrackObjectPresentationActionTrigger(const
     ItemManager::get()->newItem(m_init_xyz, trigger_distance, this);
 }
 
+// ----------------------------------------------------------------------------
 void TrackObjectPresentationActionTrigger::onTriggerItemApproached(Item* who)
 {
     if (!m_action_active) return;