Document zoom_fov in settingtypes.txt and minetest.conf.example

[dragonfireclient.git] / src / particles.cpp

diff --git a/src/particles.cpp b/src/particles.cpp
index ebb54a49a1207a61ae1d8fdfba39fab6a774c327..ccca691d17d76267f386c7f91b801e1d922dbc74 100644 (file)
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -54,6 +54,7 @@ Particle::Particle(
        float expirationtime,
        float size,
        bool collisiondetection,
        float expirationtime,
        float size,
        bool collisiondetection,

+       bool collision_removal,

        bool vertical,
        video::ITexture *texture,
        v2f texpos,
        bool vertical,
        video::ITexture *texture,
        v2f texpos,


@@ -85,10 +86,11 @@ Particle::Particle(
        m_player = player;
        m_size = size;
        m_collisiondetection = collisiondetection;
        m_player = player;
        m_size = size;
        m_collisiondetection = collisiondetection;

+       m_collision_removal = collision_removal;

        m_vertical = vertical;
 
        // Irrlicht stuff
        m_vertical = vertical;
 
        // Irrlicht stuff

-       m_collisionbox = core::aabbox3d<f32>
+       m_collisionbox = aabb3f

                        (-size/2,-size/2,-size/2,size/2,size/2,size/2);
        this->setAutomaticCulling(scene::EAC_OFF);
 
                        (-size/2,-size/2,-size/2,size/2,size/2,size/2);
        this->setAutomaticCulling(scene::EAC_OFF);
 


@@ -126,22 +128,21 @@ void Particle::render()
 void Particle::step(float dtime)
 {
        m_time += dtime;
 void Particle::step(float dtime)
 {
        m_time += dtime;

-       if (m_collisiondetection)
-       {
-               core::aabbox3d<f32> box = m_collisionbox;
-               v3f p_pos = m_pos*BS;
-               v3f p_velocity = m_velocity*BS;
-               v3f p_acceleration = m_acceleration*BS;
-               collisionMoveSimple(m_env, m_gamedef,
-                       BS*0.5, box,
-                       0, dtime,
-                       p_pos, p_velocity, p_acceleration);
-               m_pos = p_pos/BS;
-               m_velocity = p_velocity/BS;
-               m_acceleration = p_acceleration/BS;
-       }
-       else
-       {
+       if (m_collisiondetection) {
+               aabb3f box = m_collisionbox;
+               v3f p_pos = m_pos * BS;
+               v3f p_velocity = m_velocity * BS;
+               collisionMoveResult r = collisionMoveSimple(m_env,
+                       m_gamedef, BS * 0.5, box, 0, dtime, &p_pos,
+                       &p_velocity, m_acceleration * BS);
+               if (m_collision_removal && r.collides) {
+                       // force expiration of the particle
+                       m_expiration = -1.0;
+               } else {
+                       m_pos = p_pos / BS;
+                       m_velocity = p_velocity / BS;
+               }
+       } else {

                m_velocity += m_acceleration * dtime;
                m_pos += m_velocity * dtime;
        }
                m_velocity += m_acceleration * dtime;
                m_pos += m_velocity * dtime;
        }


@@ -212,8 +213,8 @@ 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,
        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,
-       ParticleManager *p_manager) :
+       bool collisiondetection, bool collision_removal, bool vertical,
+       video::ITexture *texture, u32 id, ParticleManager *p_manager) :

        m_particlemanager(p_manager)
 {
        m_gamedef = gamedef;
        m_particlemanager(p_manager)
 {
        m_gamedef = gamedef;


@@ -232,6 +233,7 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
        m_minsize = minsize;
        m_maxsize = maxsize;
        m_collisiondetection = collisiondetection;
        m_minsize = minsize;
        m_maxsize = maxsize;
        m_collisiondetection = collisiondetection;

+       m_collision_removal = collision_removal;

        m_vertical = vertical;
        m_texture = texture;
        m_time = 0;
        m_vertical = vertical;
        m_texture = texture;
        m_time = 0;


@@ -279,6 +281,7 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
                                        exptime,
                                        size,
                                        m_collisiondetection,
                                        exptime,
                                        size,
                                        m_collisiondetection,

+                                       m_collision_removal,

                                        m_vertical,
                                        m_texture,
                                        v2f(0.0, 0.0),
                                        m_vertical,
                                        m_texture,
                                        v2f(0.0, 0.0),


@@ -319,6 +322,7 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
                                        exptime,
                                        size,
                                        m_collisiondetection,
                                        exptime,
                                        size,
                                        m_collisiondetection,

+                                       m_collision_removal,

                                        m_vertical,
                                        m_texture,
                                        v2f(0.0, 0.0),
                                        m_vertical,
                                        m_texture,
                                        v2f(0.0, 0.0),


@@ -348,7 +352,7 @@ void ParticleManager::step(float dtime)
 void ParticleManager::stepSpawners (float dtime)
 {
        MutexAutoLock lock(m_spawner_list_lock);
 void ParticleManager::stepSpawners (float dtime)
 {
        MutexAutoLock lock(m_spawner_list_lock);

-       for(std::map<u32, ParticleSpawner*>::iterator i = 
+       for (std::map<u32, ParticleSpawner*>::iterator i =

                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)
        {
                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)
        {


@@ -410,94 +414,94 @@ void ParticleManager::clearAll ()
 void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
                scene::ISceneManager* smgr, LocalPlayer *player)
 {
 void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
                scene::ISceneManager* smgr, LocalPlayer *player)
 {

-       if (event->type == CE_DELETE_PARTICLESPAWNER) {
-               MutexAutoLock 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);
+       switch (event->type) {
+               case CE_DELETE_PARTICLESPAWNER: {
+                       MutexAutoLock 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
+                       break;

                }
                }

-               // no allocated memory in delete event
-               return;
-       }
+               case CE_ADD_PARTICLESPAWNER: {
+                       {
+                               MutexAutoLock lock(m_spawner_list_lock);
+                               if (m_particle_spawners.find(event->add_particlespawner.id) !=
+                                               m_particle_spawners.end()) {
+                                       delete m_particle_spawners.find(event->add_particlespawner.id)->second;
+                                       m_particle_spawners.erase(event->add_particlespawner.id);
+                               }
+                       }

 
 

-       if (event->type == CE_ADD_PARTICLESPAWNER) {
+                       video::ITexture *texture =
+                               gamedef->tsrc()->getTextureForMesh(*(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.collision_removal,
+                                       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;

 
 

-               {
-                       MutexAutoLock lock(m_spawner_list_lock);
-                       if (m_particle_spawners.find(event->add_particlespawner.id) !=
-                                                       m_particle_spawners.end())

                        {
                        {

-                               delete m_particle_spawners.find(event->add_particlespawner.id)->second;
-                               m_particle_spawners.erase(event->add_particlespawner.id);
+                               MutexAutoLock lock(m_spawner_list_lock);
+                               m_particle_spawners.insert(
+                                               std::pair<u32, ParticleSpawner*>(
+                                                               event->add_particlespawner.id,
+                                                               toadd));

                        }
                        }

+                       break;

                }
                }

-               video::ITexture *texture =
-                       gamedef->tsrc()->getTextureForMesh(*(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;
+               case CE_SPAWN_PARTICLE: {
+                       video::ITexture *texture =
+                               gamedef->tsrc()->getTextureForMesh(*(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.collision_removal,
+                                       event->spawn_particle.vertical,
+                                       texture,
+                                       v2f(0.0, 0.0),
+                                       v2f(1.0, 1.0));

 
 

-               {
-                       MutexAutoLock lock(m_spawner_list_lock);
-                       m_particle_spawners.insert(
-                                       std::pair<u32, ParticleSpawner*>(
-                                                       event->add_particlespawner.id,
-                                                       toadd));
-               }
+                       addParticle(toadd);

 
 

-               return;
-       }
+                       delete event->spawn_particle.pos;
+                       delete event->spawn_particle.vel;
+                       delete event->spawn_particle.acc;

 
 

-       if (event->type == CE_SPAWN_PARTICLE) {
-               video::ITexture *texture =
-                       gamedef->tsrc()->getTextureForMesh(*(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;
+                       break;
+               }
+               default: break;

        }
 }
 
        }
 }
 


@@ -559,6 +563,7 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
                visual_size,
                true,
                false,
                visual_size,
                true,
                false,

+               false,

                texture,
                texpos,
                texsize);
                texture,
                texpos,
                texsize);