ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
hiker 2014-10-13 08:26:45 +11:00
parent 216575a732
commit bfe84612fa
19 changed files with 175 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/audio/dummy_sfx.hpp
View File

@ -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; }

4
src/audio/sfx_base.hpp
View File

@ -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;

71
src/audio/sfx_manager.cpp
View File

@ -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();
@ -226,7 +228,15 @@ void* SFXManager::mainLoop(void *obj)
me->m_sfx_commands.unlock();
switch(current->m_command)
{
case SFX_PLAY: current->m_sfx->reallyPlayNow(); break;
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();
const int sfx_amount = (int)m_all_sfx.size();
m_all_sfx.lock();
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);
// 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.end())
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();
i!=m_all_sfx.end(); i++)
m_all_sfx.lock();
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();
i!=m_all_sfx.end(); i++)
m_all_sfx.lock();
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();
i!=m_all_sfx.end(); i++)
m_all_sfx.lock();
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

4
src/audio/sfx_manager.hpp
View File

@ -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();

45
src/audio/sfx_openal.cpp
View File

@ -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

4
src/audio/sfx_openal.hpp
View File

@ -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);

5
src/graphics/hit_sfx.cpp
View File

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

6
src/graphics/weather.cpp
View File

@ -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
// ----------------------------------------------------------------------------

14
src/items/attachment.cpp
View File

@ -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();
SFXManager::get()->deleteSFX(m_bomb_sound);
m_bomb_sound->deleteSFX();
m_bomb_sound = NULL;
}
@ -460,8 +459,7 @@ void Attachment::update(float dt)
if (m_bomb_sound)
{
m_bomb_sound->stop();
SFXManager::get()->deleteSFX(m_bomb_sound);
m_bomb_sound->deleteSFX();
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();

6
src/items/bowling.cpp
View File

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

4
src/items/powerup.cpp
View File

@ -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;
}

2
src/items/rubber_ball.cpp
View File

@ -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
// ----------------------------------------------------------------------------

2
src/items/swatter.cpp
View File

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

10
src/karts/controller/player_controller.cpp
View File

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

31
src/karts/kart.cpp
View File

@ -246,15 +246,15 @@ Kart::~Kart()
SFXManager::get()->deleteSFX(m_custom_sounds[n]);
}*/
SFXManager::get()->deleteSFX(m_engine_sound );
SFXManager::get()->deleteSFX(m_crash_sound );
SFXManager::get()->deleteSFX(m_skid_sound );
SFXManager::get()->deleteSFX(m_goo_sound );
SFXManager::get()->deleteSFX(m_beep_sound );
SFXManager::get()->deleteSFX(m_boing_sound );
m_engine_sound->deleteSFX();
m_crash_sound ->deleteSFX();
m_skid_sound ->deleteSFX();
m_goo_sound ->deleteSFX();
m_beep_sound ->deleteSFX();
m_boing_sound ->deleteSFX();
delete m_kart_gfx;
if(m_terrain_sound) SFXManager::get()->deleteSFX(m_terrain_sound);
if(m_previous_terrain_sound) SFXManager::get()->deleteSFX(m_previous_terrain_sound);
if(m_terrain_sound) m_terrain_sound->deleteSFX();
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,16 +363,15 @@ 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_previous_terrain_sound = NULL;
}
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);

2
src/modes/linear_world.cpp
View File

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

2
src/modes/soccer_world.cpp
View File

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

6
src/modes/world_status.cpp
View File

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

44
src/tracks/track_object_presentation.cpp
View File

@ -382,8 +382,9 @@ void TrackObjectPresentationMesh::reset()
// ----------------------------------------------------------------------------
TrackObjectPresentationSound::TrackObjectPresentationSound(const XMLNode& xml_node, scene::ISceneNode* parent) :
TrackObjectPresentation(xml_node)
TrackObjectPresentationSound::TrackObjectPresentationSound(const XMLNode& 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();
SFXManager::get()->deleteSFX(m_sound);
m_sound->deleteSFX();
}
}
} // ~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, scene::ISceneNode* parent) :
TrackObjectPresentationSceneNode(xml_node)
TrackObjectPresentationBillboard::TrackObjectPresentationBillboard(const XMLNode& xml_node,
scene::ISceneNode* parent)
: 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;