Fix memory leaks due to messed up memory handling for particles as well as their spawners

1 files changed, 220 insertions, 120 deletions

diff --git a/src/particles.cpp b/src/particles.cpp
index b1662e10b..b32ec1542 100644
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -31,6 +31,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "environment.h"
 #include "clientmap.h"
 #include "mapnode.h"
+#include "client.h"
 
 /*
 	Utility
@@ -43,14 +44,11 @@ v3f random_v3f(v3f min, v3f max)
 			rand()/(float)RAND_MAX*(max.Z-min.Z)+min.Z);
 }
 
-std::vector<Particle*> all_particles;
-std::map<u32, ParticleSpawner*> all_particlespawners;
-
 Particle::Particle(
 	IGameDef *gamedef,
 	scene::ISceneManager* smgr,
 	LocalPlayer *player,
-	ClientEnvironment &env,
+	ClientEnvironment *env,
 	v3f pos,
 	v3f velocity,
 	v3f acceleration,
@@ -66,7 +64,7 @@ Particle::Particle(
 {
 	// Misc
 	m_gamedef = gamedef;
-	m_env = &env;
+	m_env = env;
 
 	// Texture
 	m_material.setFlag(video::EMF_LIGHTING, false);
@@ -100,8 +98,6 @@ Particle::Particle(
 
 	// Init model
 	updateVertices();
-
-	all_particles.push_back(this);
 }
 
 Particle::~Particle()
@@ -217,98 +213,6 @@ void Particle::updateVertices()
 }
 
 /*
-	Helpers
-*/
-
-
-void allparticles_step (float dtime)
-{
-	for(std::vector<Particle*>::iterator i = all_particles.begin();
-			i != all_particles.end();)
-	{
-		if ((*i)->get_expired())
-		{
-			(*i)->remove();
-			delete *i;
-			i = all_particles.erase(i);
-		}
-		else
-		{
-			(*i)->step(dtime);
-			i++;
-		}
-	}
-}
-
-void addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
-		LocalPlayer *player, ClientEnvironment &env, v3s16 pos,
-		const TileSpec tiles[])
-{
-	for (u16 j = 0; j < 32; j++) // set the amount of particles here
-	{
-		addNodeParticle(gamedef, smgr, player, env, pos, tiles);
-	}
-}
-
-void addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
-		LocalPlayer *player, ClientEnvironment &env,
-		v3s16 pos, const TileSpec tiles[])
-{
-	addNodeParticle(gamedef, smgr, player, env, pos, tiles);
-}
-
-// add a particle of a node
-// used by digging and punching particles
-void addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
-		LocalPlayer *player, ClientEnvironment &env, v3s16 pos,
-		const TileSpec tiles[])
-{
-	// Texture
-	u8 texid = myrand_range(0,5);
-	video::ITexture *texture = tiles[texid].texture;
-
-	// Only use first frame of animated texture
-	f32 ymax = 1;
-	if(tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
-		ymax /= tiles[texid].animation_frame_count;
-
-	float size = rand()%64/512.;
-	float visual_size = BS*size;
-	v2f texsize(size*2, ymax*size*2);
-	v2f texpos;
-	texpos.X = ((rand()%64)/64.-texsize.X);
-	texpos.Y = ymax*((rand()%64)/64.-texsize.Y);
-
-	// Physics
-	v3f velocity(	(rand()%100/50.-1)/1.5,
-			rand()%100/35.,
-			(rand()%100/50.-1)/1.5);
-
-	v3f acceleration(0,-9,0);
-	v3f particlepos = v3f(
-		(f32)pos.X+rand()%100/200.-0.25,
-		(f32)pos.Y+rand()%100/200.-0.25,
-		(f32)pos.Z+rand()%100/200.-0.25
-	);
-
-	new Particle(
-		gamedef,
-		smgr,
-		player,
-		env,
-		particlepos,
-		velocity,
-		acceleration,
-		rand()%100/100., // expiration time
-		visual_size,
-		true,
-		false,
-		texture,
-		texpos,
-		texsize);
-}
-
-/*
 	ParticleSpawner
 */
 
@@ -316,7 +220,9 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
 	u16 amount, float time,
 	v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
 	float minexptime, float maxexptime, float minsize, float maxsize,
-	bool collisiondetection, bool vertical, video::ITexture *texture, u32 id)
+	bool collisiondetection, bool vertical, video::ITexture *texture, u32 id,
+	ParticleManager *p_manager) :
+	m_particlemanager(p_manager)
 {
 	m_gamedef = gamedef;
 	m_smgr = smgr;
@@ -343,13 +249,11 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
 		float spawntime = (float)rand()/(float)RAND_MAX*m_spawntime;
 		m_spawntimes.push_back(spawntime);
 	}
-
-	all_particlespawners.insert(std::pair<u32, ParticleSpawner*>(id, this));
 }
 
 ParticleSpawner::~ParticleSpawner() {}
 
-void ParticleSpawner::step(float dtime, ClientEnvironment &env)
+void ParticleSpawner::step(float dtime, ClientEnvironment* env)
 {
 	m_time += dtime;
 
@@ -372,7 +276,7 @@ void ParticleSpawner::step(float dtime, ClientEnvironment &env)
 						*(m_maxsize-m_minsize)
 						+m_minsize;
 
-				new Particle(
+				Particle* toadd = new Particle(
 					m_gamedef,
 					m_smgr,
 					m_player,
@@ -387,6 +291,7 @@ void ParticleSpawner::step(float dtime, ClientEnvironment &env)
 					m_texture,
 					v2f(0.0, 0.0),
 					v2f(1.0, 1.0));
+				m_particlemanager->addParticle(toadd);
 				i = m_spawntimes.erase(i);
 			}
 			else
@@ -431,50 +336,245 @@ void ParticleSpawner::step(float dtime, ClientEnvironment &env)
 	}
 }
 
-void allparticlespawners_step (float dtime, ClientEnvironment &env)
+
+ParticleManager::ParticleManager(ClientEnvironment* env) :
+	m_env(env)
+{}
+
+ParticleManager::~ParticleManager()
+{
+	clearAll();
+}
+
+void ParticleManager::step(float dtime)
 {
+	stepParticles (dtime);
+	stepSpawners (dtime);
+}
+
+void ParticleManager::stepSpawners (float dtime)
+{
+	JMutexAutoLock lock(m_spawner_list_lock);
 	for(std::map<u32, ParticleSpawner*>::iterator i = 
-			all_particlespawners.begin();
-			i != all_particlespawners.end();)
+			m_particle_spawners.begin();
+			i != m_particle_spawners.end();)
 	{
 		if (i->second->get_expired())
 		{
 			delete i->second;
-			all_particlespawners.erase(i++);
+			m_particle_spawners.erase(i++);
 		}
 		else
 		{
-			i->second->step(dtime, env);
+			i->second->step(dtime, m_env);
 			i++;
 		}
 	}
 }
 
-void delete_particlespawner (u32 id)
+void ParticleManager::stepParticles (float dtime)
 {
-	if (all_particlespawners.find(id) != all_particlespawners.end())
+	JMutexAutoLock lock(m_particle_list_lock);
+	for(std::vector<Particle*>::iterator i = m_particles.begin();
+			i != m_particles.end();)
 	{
-		delete all_particlespawners.find(id)->second;
-		all_particlespawners.erase(id);
+		if ((*i)->get_expired())
+		{
+			(*i)->remove();
+			delete *i;
+			i = m_particles.erase(i);
+		}
+		else
+		{
+			(*i)->step(dtime);
+			i++;
+		}
 	}
 }
 
-void clear_particles ()
+void ParticleManager::clearAll ()
 {
+	JMutexAutoLock lock(m_spawner_list_lock);
+	JMutexAutoLock lock2(m_particle_list_lock);
 	for(std::map<u32, ParticleSpawner*>::iterator i =
-			all_particlespawners.begin();
-			i != all_particlespawners.end();)
+			m_particle_spawners.begin();
+			i != m_particle_spawners.end();)
 	{
 		delete i->second;
-		all_particlespawners.erase(i++);
+		m_particle_spawners.erase(i++);
 	}
 
 	for(std::vector<Particle*>::iterator i =
-			all_particles.begin();
-			i != all_particles.end();)
+			m_particles.begin();
+			i != m_particles.end();)
 	{
 		(*i)->remove();
 		delete *i;
-		i = all_particles.erase(i);
+		i = m_particles.erase(i);
+	}
+}
+
+void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
+		scene::ISceneManager* smgr, LocalPlayer *player)
+{
+	if (event->type == CE_DELETE_PARTICLESPAWNER) {
+		JMutexAutoLock lock(m_spawner_list_lock);
+		if (m_particle_spawners.find(event->delete_particlespawner.id) !=
+				m_particle_spawners.end())
+		{
+			delete m_particle_spawners.find(event->delete_particlespawner.id)->second;
+			m_particle_spawners.erase(event->delete_particlespawner.id);
+		}
+		// no allocated memory in delete event
+		return;
+	}
+
+	if (event->type == CE_ADD_PARTICLESPAWNER) {
+
+		{
+			JMutexAutoLock lock(m_spawner_list_lock);
+			if (m_particle_spawners.find(event->delete_particlespawner.id) !=
+							m_particle_spawners.end())
+			{
+				delete m_particle_spawners.find(event->delete_particlespawner.id)->second;
+				m_particle_spawners.erase(event->delete_particlespawner.id);
+			}
+		}
+		video::ITexture *texture =
+			gamedef->tsrc()->getTexture(*(event->add_particlespawner.texture));
+
+		ParticleSpawner* toadd = new ParticleSpawner(gamedef, smgr, player,
+				event->add_particlespawner.amount,
+				event->add_particlespawner.spawntime,
+				*event->add_particlespawner.minpos,
+				*event->add_particlespawner.maxpos,
+				*event->add_particlespawner.minvel,
+				*event->add_particlespawner.maxvel,
+				*event->add_particlespawner.minacc,
+				*event->add_particlespawner.maxacc,
+				event->add_particlespawner.minexptime,
+				event->add_particlespawner.maxexptime,
+				event->add_particlespawner.minsize,
+				event->add_particlespawner.maxsize,
+				event->add_particlespawner.collisiondetection,
+				event->add_particlespawner.vertical,
+				texture,
+				event->add_particlespawner.id,
+				this);
+
+		/* delete allocated content of event */
+		delete event->add_particlespawner.minpos;
+		delete event->add_particlespawner.maxpos;
+		delete event->add_particlespawner.minvel;
+		delete event->add_particlespawner.maxvel;
+		delete event->add_particlespawner.minacc;
+		delete event->add_particlespawner.texture;
+		delete event->add_particlespawner.maxacc;
+
+		{
+			JMutexAutoLock lock(m_spawner_list_lock);
+			m_particle_spawners.insert(
+					std::pair<u32, ParticleSpawner*>(
+							event->delete_particlespawner.id,
+							toadd));
+		}
+
+		return;
+	}
+
+	if (event->type == CE_SPAWN_PARTICLE) {
+		video::ITexture *texture =
+			gamedef->tsrc()->getTexture(*(event->spawn_particle.texture));
+
+		Particle* toadd = new Particle(gamedef, smgr, player, m_env,
+				*event->spawn_particle.pos,
+				*event->spawn_particle.vel,
+				*event->spawn_particle.acc,
+				event->spawn_particle.expirationtime,
+				event->spawn_particle.size,
+				event->spawn_particle.collisiondetection,
+				event->spawn_particle.vertical,
+				texture,
+				v2f(0.0, 0.0),
+				v2f(1.0, 1.0));
+
+		addParticle(toadd);
+
+		delete event->spawn_particle.pos;
+		delete event->spawn_particle.vel;
+		delete event->spawn_particle.acc;
+
+		return;
 	}
 }
+
+void ParticleManager::addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
+		LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+{
+	for (u16 j = 0; j < 32; j++) // set the amount of particles here
+	{
+		addNodeParticle(gamedef, smgr, player, pos, tiles);
+	}
+}
+
+void ParticleManager::addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
+		LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+{
+	addNodeParticle(gamedef, smgr, player, pos, tiles);
+}
+
+void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
+		LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+{
+	// Texture
+	u8 texid = myrand_range(0, 5);
+	video::ITexture *texture = tiles[texid].texture;
+
+	// Only use first frame of animated texture
+	f32 ymax = 1;
+	if(tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
+		ymax /= tiles[texid].animation_frame_count;
+
+	float size = rand() % 64 / 512.;
+	float visual_size = BS * size;
+	v2f texsize(size * 2, ymax * size * 2);
+	v2f texpos;
+	texpos.X = ((rand() % 64) / 64. - texsize.X);
+	texpos.Y = ymax * ((rand() % 64) / 64. - texsize.Y);
+
+	// Physics
+	v3f velocity((rand() % 100 / 50. - 1) / 1.5,
+			rand() % 100 / 35.,
+			(rand() % 100 / 50. - 1) / 1.5);
+
+	v3f acceleration(0,-9,0);
+	v3f particlepos = v3f(
+		(f32) pos.X + rand() %100 /200. - 0.25,
+		(f32) pos.Y + rand() %100 /200. - 0.25,
+		(f32) pos.Z + rand() %100 /200. - 0.25
+	);
+
+	Particle* toadd = new Particle(
+		gamedef,
+		smgr,
+		player,
+		m_env,
+		particlepos,
+		velocity,
+		acceleration,
+		rand() % 100 / 100., // expiration time
+		visual_size,
+		true,
+		false,
+		texture,
+		texpos,
+		texsize);
+
+	addParticle(toadd);
+}
+
+void ParticleManager::addParticle(Particle* toadd)
+{
+	JMutexAutoLock lock(m_particle_list_lock);
+	m_particles.push_back(toadd);
+}