if (sky)
sky->drop();
- clear_particles();
-
/* cleanup menus */
while (g_menumgr.menuCount() > 0) {
g_menumgr.m_stack.front()->setVisible(false);
delete(event.show_formspec.formspec);
delete(event.show_formspec.formname);
- } else if (event.type == CE_SPAWN_PARTICLE) {
- video::ITexture *texture =
- gamedef->tsrc()->getTexture(*(event.spawn_particle.texture));
-
- new Particle(gamedef, smgr, player, client->getEnv(),
- *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));
- } else if (event.type == CE_ADD_PARTICLESPAWNER) {
- video::ITexture *texture =
- gamedef->tsrc()->getTexture(*(event.add_particlespawner.texture));
-
- 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);
- } else if (event.type == CE_DELETE_PARTICLESPAWNER) {
- delete_particlespawner(event.delete_particlespawner.id);
+ } else if ((event.type == CE_SPAWN_PARTICLE) ||
+ (event.type == CE_ADD_PARTICLESPAWNER) ||
+ (event.type == CE_DELETE_PARTICLESPAWNER)) {
+ client->getParticleManager()->handleParticleEvent(&event, gamedef,
+ smgr, player);
} else if (event.type == CE_HUDADD) {
u32 id = event.hudadd.id;
if (m_cache_enable_particles) {
const ContentFeatures &features =
client->getNodeDefManager()->get(n);
- addPunchingParticles(gamedef, smgr, player,
- client->getEnv(), nodepos, features.tiles);
+ client->getParticleManager()->addPunchingParticles(gamedef, smgr,
+ player, nodepos, features.tiles);
}
}
if (m_cache_enable_particles) {
const ContentFeatures &features =
client->getNodeDefManager()->get(wasnode);
- addDiggingParticles
- (gamedef, smgr, player, client->getEnv(),
- nodepos, features.tiles);
+ client->getParticleManager()->addDiggingParticles(gamedef, smgr,
+ player, nodepos, features.tiles);
}
runData->dig_time = 0;
/*
Update particles
*/
-
- allparticles_step(dtime);
- allparticlespawners_step(dtime, client->getEnv());
+ client->getParticleManager()->step(dtime);
/*
Fog
#include "environment.h"
#include "clientmap.h"
#include "mapnode.h"
+#include "client.h"
/*
Utility
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,
{
// Misc
m_gamedef = gamedef;
- m_env = &env;
+ m_env = env;
// Texture
m_material.setFlag(video::EMF_LIGHTING, false);
// Init model
updateVertices();
-
- all_particles.push_back(this);
}
Particle::~Particle()
}
}
-/*
- 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
*/
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;
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;
*(m_maxsize-m_minsize)
+m_minsize;
- new Particle(
+ Particle* toadd = new Particle(
m_gamedef,
m_smgr,
m_player,
m_texture,
v2f(0.0, 0.0),
v2f(1.0, 1.0));
+ m_particlemanager->addParticle(toadd);
i = m_spawntimes.erase(i);
}
else
}
}
-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);
+}
#include "localplayer.h"
#include "environment.h"
+struct ClientEvent;
+class ParticleManager;
+
class Particle : public scene::ISceneNode
{
public:
IGameDef* gamedef,
scene::ISceneManager* mgr,
LocalPlayer *player,
- ClientEnvironment &env,
+ ClientEnvironment *env,
v3f pos,
v3f velocity,
v3f acceleration,
bool collisiondetection,
bool vertical,
video::ITexture *texture,
- u32 id);
+ u32 id,
+ ParticleManager* p_manager);
~ParticleSpawner();
- void step(float dtime, ClientEnvironment &env);
+ void step(float dtime, ClientEnvironment *env);
bool get_expired ()
{ return (m_amount <= 0) && m_spawntime != 0; }
private:
+ ParticleManager* m_particlemanager;
float m_time;
IGameDef *m_gamedef;
scene::ISceneManager *m_smgr;
std::vector<float> m_spawntimes;
bool m_collisiondetection;
bool m_vertical;
+
};
-void allparticles_step (float dtime);
-void allparticlespawners_step (float dtime, ClientEnvironment &env);
+/**
+ * Class doing particle as well as their spawners handling
+ */
+class ParticleManager
+{
+friend class ParticleSpawner;
+public:
+ ParticleManager(ClientEnvironment* env);
+ ~ParticleManager();
+
+ void step (float dtime);
+
+ void handleParticleEvent(ClientEvent *event,IGameDef *gamedef,
+ scene::ISceneManager* smgr, LocalPlayer *player);
+
+ void addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
+ LocalPlayer *player, v3s16 pos, const TileSpec tiles[]);
-void delete_particlespawner (u32 id);
-void clear_particles ();
+ void addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
+ LocalPlayer *player, v3s16 pos, const TileSpec tiles[]);
-void addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
- LocalPlayer *player, ClientEnvironment &env, v3s16 pos,
- const TileSpec tiles[]);
+ void addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
+ LocalPlayer *player, v3s16 pos, const TileSpec tiles[]);
-void addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
- LocalPlayer *player, ClientEnvironment &env, v3s16 pos,
- const TileSpec tiles[]);
+protected:
+ void addParticle(Particle* toadd);
-void addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
- LocalPlayer *player, ClientEnvironment &env, v3s16 pos,
- const TileSpec tiles[]);
+private:
+
+ void stepParticles (float dtime);
+ void stepSpawners (float dtime);
+
+ void clearAll ();
+
+ std::vector<Particle*> m_particles;
+ std::map<u32, ParticleSpawner*> m_particle_spawners;
+
+ ClientEnvironment* m_env;
+ JMutex m_particle_list_lock;
+ JMutex m_spawner_list_lock;
+};
#endif
projects / oweals / minetest.git / commitdiff