Remove `mathconstants.h` and use the correct way to get `M_PI` in MSVC. (#5072)

[minetest.git] / src / particles.cpp

diff --git a/src/particles.cpp b/src/particles.cpp
index 15e2a6597b952bec34dbafcdf9269a25a080599f..5f17763e013373cf2ef4423facbb1122635496fe 100644 (file)
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -18,11 +18,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 */
 
 #include "particles.h"
 */
 
 #include "particles.h"

-#include "constants.h"
-#include "debug.h"
-#include "settings.h"
-#include "client/tile.h"
-#include "gamedef.h"
+#include "client.h"

 #include "collision.h"
 #include <stdlib.h>
 #include "util/numeric.h"
 #include "collision.h"
 #include <stdlib.h>
 #include "util/numeric.h"


@@ -54,10 +50,13 @@ 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,

-       v2f texsize
+       v2f texsize,
+       const struct TileAnimationParams &anim,
+       u8 glow

 ):
        scene::ISceneNode(smgr->getRootSceneNode(), smgr)
 {
 ):
        scene::ISceneNode(smgr->getRootSceneNode(), smgr)
 {


@@ -74,7 +73,9 @@ Particle::Particle(
        m_material.setTexture(0, texture);
        m_texpos = texpos;
        m_texsize = texsize;
        m_material.setTexture(0, texture);
        m_texpos = texpos;
        m_texsize = texsize;

-
+       m_animation = anim;
+       m_animation_frame = 0;
+       m_animation_time = 0.0;

 
        // Particle related
        m_pos = pos;
 
        // Particle related
        m_pos = pos;


@@ -85,10 +86,12 @@ 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;
        m_vertical = vertical;

+       m_glow = glow;

 
        // Irrlicht stuff
 
        // 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,25 +129,36 @@ 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;
        }

+       if (m_animation.type != TAT_NONE) {
+               m_animation_time += dtime;
+               int frame_length_i, frame_count;
+               m_animation.determineParams(
+                               m_material.getTexture(0)->getSize(),
+                               &frame_count, &frame_length_i, NULL);
+               float frame_length = frame_length_i / 1000.0;
+               while (m_animation_time > frame_length) {
+                       m_animation_frame++;
+                       m_animation_time -= frame_length;
+               }
+       }

 
        // Update lighting
        updateLight();
 
        // Update lighting
        updateLight();


@@ -169,16 +183,32 @@ void Particle::updateLight()
        else
                light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
 
        else
                light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
 

-       m_light = decode_light(light);
+       m_light = decode_light(light + m_glow);

 }
 
 void Particle::updateVertices()
 {
        video::SColor c(255, m_light, m_light, m_light);
 }
 
 void Particle::updateVertices()
 {
        video::SColor c(255, m_light, m_light, m_light);

-       f32 tx0 = m_texpos.X;
-       f32 tx1 = m_texpos.X + m_texsize.X;
-       f32 ty0 = m_texpos.Y;
-       f32 ty1 = m_texpos.Y + m_texsize.Y;
+       f32 tx0, tx1, ty0, ty1;
+
+       if (m_animation.type != TAT_NONE) {
+               const v2u32 texsize = m_material.getTexture(0)->getSize();
+               v2f texcoord, framesize_f;
+               v2u32 framesize;
+               texcoord = m_animation.getTextureCoords(texsize, m_animation_frame);
+               m_animation.determineParams(texsize, NULL, NULL, &framesize);
+               framesize_f = v2f(framesize.X / (float) texsize.X, framesize.Y / (float) texsize.Y);
+
+               tx0 = m_texpos.X + texcoord.X;
+               tx1 = m_texpos.X + texcoord.X + framesize_f.X * m_texsize.X;
+               ty0 = m_texpos.Y + texcoord.Y;
+               ty1 = m_texpos.Y + texcoord.Y + framesize_f.Y * m_texsize.Y;
+       } else {
+               tx0 = m_texpos.X;
+               tx1 = m_texpos.X + m_texsize.X;
+               ty0 = m_texpos.Y;
+               ty1 = m_texpos.Y + m_texsize.Y;
+       }

 
        m_vertices[0] = video::S3DVertex(-m_size/2,-m_size/2,0, 0,0,0,
                        c, tx0, ty1);
 
        m_vertices[0] = video::S3DVertex(-m_size/2,-m_size/2,0, 0,0,0,
                        c, tx0, ty1);


@@ -212,7 +242,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,
        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 collision_removal, u16 attached_id, bool vertical,
+       video::ITexture *texture, u32 id, const struct TileAnimationParams &anim,
+       u8 glow,

        ParticleManager *p_manager) :
        m_particlemanager(p_manager)
 {
        ParticleManager *p_manager) :
        m_particlemanager(p_manager)
 {


@@ -232,9 +264,13 @@ 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_attached_id = attached_id;

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

+       m_animation = anim;
+       m_glow = glow;

 
        for (u16 i = 0; i<=m_amount; i++)
        {
 
        for (u16 i = 0; i<=m_amount; i++)
        {


@@ -249,6 +285,20 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
 {
        m_time += dtime;
 
 {
        m_time += dtime;
 

+       bool unloaded = false;
+       bool is_attached = false;
+       v3f attached_pos = v3f(0,0,0);
+       float attached_yaw = 0;
+       if (m_attached_id != 0) {
+               if (ClientActiveObject *attached = env->getActiveObject(m_attached_id)) {
+                       attached_pos = attached->getPosition() / BS;
+                       attached_yaw = attached->getYaw();
+                       is_attached = true;
+               } else {
+                       unloaded = true;
+               }
+       }
+

        if (m_spawntime != 0) // Spawner exists for a predefined timespan
        {
                for(std::vector<float>::iterator i = m_spawntimes.begin();
        if (m_spawntime != 0) // Spawner exists for a predefined timespan
        {
                for(std::vector<float>::iterator i = m_spawntimes.begin();


@@ -258,42 +308,62 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
                        {
                                m_amount--;
 
                        {
                                m_amount--;
 

-                               v3f pos = random_v3f(m_minpos, m_maxpos);
-                               v3f vel = random_v3f(m_minvel, m_maxvel);
-                               v3f acc = random_v3f(m_minacc, m_maxacc);
-                               float exptime = rand()/(float)RAND_MAX
-                                               *(m_maxexptime-m_minexptime)
-                                               +m_minexptime;
-                               float size = rand()/(float)RAND_MAX
-                                               *(m_maxsize-m_minsize)
-                                               +m_minsize;
-
-                               Particle* toadd = new Particle(
-                                       m_gamedef,
-                                       m_smgr,
-                                       m_player,
-                                       env,
-                                       pos,
-                                       vel,
-                                       acc,
-                                       exptime,
-                                       size,
-                                       m_collisiondetection,
-                                       m_vertical,
-                                       m_texture,
-                                       v2f(0.0, 0.0),
-                                       v2f(1.0, 1.0));
-                               m_particlemanager->addParticle(toadd);
+                               // Pretend to, but don't actually spawn a
+                               // particle if it is attached to an unloaded
+                               // object.
+                               if (!unloaded) {
+                                       v3f pos = random_v3f(m_minpos, m_maxpos);
+                                       v3f vel = random_v3f(m_minvel, m_maxvel);
+                                       v3f acc = random_v3f(m_minacc, m_maxacc);
+
+                                       if (is_attached) {
+                                               // Apply attachment yaw and position
+                                               pos.rotateXZBy(attached_yaw);
+                                               pos += attached_pos;
+                                               vel.rotateXZBy(attached_yaw);
+                                               acc.rotateXZBy(attached_yaw);
+                                       }
+
+                                       float exptime = rand()/(float)RAND_MAX
+                                                       *(m_maxexptime-m_minexptime)
+                                                       +m_minexptime;
+                                       float size = rand()/(float)RAND_MAX
+                                                       *(m_maxsize-m_minsize)
+                                                       +m_minsize;
+
+                                       Particle* toadd = new Particle(
+                                               m_gamedef,
+                                               m_smgr,
+                                               m_player,
+                                               env,
+                                               pos,
+                                               vel,
+                                               acc,
+                                               exptime,
+                                               size,
+                                               m_collisiondetection,
+                                               m_collision_removal,
+                                               m_vertical,
+                                               m_texture,
+                                               v2f(0.0, 0.0),
+                                               v2f(1.0, 1.0),
+                                               m_animation,
+                                               m_glow);
+                                       m_particlemanager->addParticle(toadd);
+                               }

                                i = m_spawntimes.erase(i);
                        }
                        else
                        {
                                i = m_spawntimes.erase(i);
                        }
                        else
                        {

-                               i++;
+                               ++i;

                        }
                }
        }
        else // Spawner exists for an infinity timespan, spawn on a per-second base
        {
                        }
                }
        }
        else // Spawner exists for an infinity timespan, spawn on a per-second base
        {

+               // Skip this step if attached to an unloaded object
+               if (unloaded)
+                       return;

                for (int i = 0; i <= m_amount; i++)
                {
                        if (rand()/(float)RAND_MAX < dtime)
                for (int i = 0; i <= m_amount; i++)
                {
                        if (rand()/(float)RAND_MAX < dtime)


@@ -301,6 +371,15 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
                                v3f pos = random_v3f(m_minpos, m_maxpos);
                                v3f vel = random_v3f(m_minvel, m_maxvel);
                                v3f acc = random_v3f(m_minacc, m_maxacc);
                                v3f pos = random_v3f(m_minpos, m_maxpos);
                                v3f vel = random_v3f(m_minvel, m_maxvel);
                                v3f acc = random_v3f(m_minacc, m_maxacc);

+
+                               if (is_attached) {
+                                       // Apply attachment yaw and position
+                                       pos.rotateXZBy(attached_yaw);
+                                       pos += attached_pos;
+                                       vel.rotateXZBy(attached_yaw);
+                                       acc.rotateXZBy(attached_yaw);
+                               }
+

                                float exptime = rand()/(float)RAND_MAX
                                                *(m_maxexptime-m_minexptime)
                                                +m_minexptime;
                                float exptime = rand()/(float)RAND_MAX
                                                *(m_maxexptime-m_minexptime)
                                                +m_minexptime;


@@ -319,10 +398,13 @@ 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),

-                                       v2f(1.0, 1.0));
+                                       v2f(1.0, 1.0),
+                                       m_animation,
+                                       m_glow);

                                m_particlemanager->addParticle(toadd);
                        }
                }
                                m_particlemanager->addParticle(toadd);
                        }
                }


@@ -347,8 +429,8 @@ void ParticleManager::step(float dtime)
 
 void ParticleManager::stepSpawners (float dtime)
 {
 
 void ParticleManager::stepSpawners (float dtime)
 {

-       JMutexAutoLock lock(m_spawner_list_lock);
-       for(std::map<u32, ParticleSpawner*>::iterator i = 
+       MutexAutoLock lock(m_spawner_list_lock);
+       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();)
        {


@@ -360,14 +442,14 @@ void ParticleManager::stepSpawners (float dtime)
                else
                {
                        i->second->step(dtime, m_env);
                else
                {
                        i->second->step(dtime, m_env);

-                       i++;
+                       ++i;

                }
        }
 }
 
 void ParticleManager::stepParticles (float dtime)
 {
                }
        }
 }
 
 void ParticleManager::stepParticles (float dtime)
 {

-       JMutexAutoLock lock(m_particle_list_lock);
+       MutexAutoLock lock(m_particle_list_lock);

        for(std::vector<Particle*>::iterator i = m_particles.begin();
                        i != m_particles.end();)
        {
        for(std::vector<Particle*>::iterator i = m_particles.begin();
                        i != m_particles.end();)
        {


@@ -380,15 +462,15 @@ void ParticleManager::stepParticles (float dtime)
                else
                {
                        (*i)->step(dtime);
                else
                {
                        (*i)->step(dtime);

-                       i++;
+                       ++i;

                }
        }
 }
 
 void ParticleManager::clearAll ()
 {
                }
        }
 }
 
 void ParticleManager::clearAll ()
 {

-       JMutexAutoLock lock(m_spawner_list_lock);
-       JMutexAutoLock lock2(m_particle_list_lock);
+       MutexAutoLock lock(m_spawner_list_lock);
+       MutexAutoLock lock2(m_particle_list_lock);

        for(std::map<u32, ParticleSpawner*>::iterator i =
                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)
        for(std::map<u32, ParticleSpawner*>::iterator i =
                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)


@@ -407,97 +489,103 @@ void ParticleManager::clearAll ()
        }
 }
 
        }
 }
 

-void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
+void ParticleManager::handleParticleEvent(ClientEvent *event, Client *client,

                scene::ISceneManager* smgr, LocalPlayer *player)
 {
                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);
+       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 =
+                               client->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
+
+                       ParticleSpawner* toadd = new ParticleSpawner(client, 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.attached_id,
+                                       event->add_particlespawner.vertical,
+                                       texture,
+                                       event->add_particlespawner.id,
+                                       event->add_particlespawner.animation,
+                                       event->add_particlespawner.glow,
+                                       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);
-                       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 =
+                               client->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
+
+                       Particle* toadd = new Particle(client, 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),
+                                       event->spawn_particle.animation,
+                                       event->spawn_particle.glow);

 
 

-               {
-                       JMutexAutoLock 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;
+                       delete event->spawn_particle.texture;

 
 

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

        }
 }
 
        }
 }
 


@@ -521,19 +609,22 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
 {
        // Texture
        u8 texid = myrand_range(0, 5);
 {
        // Texture
        u8 texid = myrand_range(0, 5);

-       video::ITexture *texture = tiles[texid].texture;
+       video::ITexture *texture;
+       struct TileAnimationParams anim;
+       anim.type = TAT_NONE;

 
        // Only use first frame of animated 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;
+       if (tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION)
+               texture = tiles[texid].frames[0].texture;
+       else
+               texture = tiles[texid].texture;

 
        float size = rand() % 64 / 512.;
        float visual_size = BS * size;
 
        float size = rand() % 64 / 512.;
        float visual_size = BS * size;

-       v2f texsize(size * 2, ymax * size * 2);
+       v2f texsize(size * 2, size * 2);

        v2f texpos;
        texpos.X = ((rand() % 64) / 64. - texsize.X);
        v2f texpos;
        texpos.X = ((rand() % 64) / 64. - texsize.X);

-       texpos.Y = ymax * ((rand() % 64) / 64. - texsize.Y);
+       texpos.Y = ((rand() % 64) / 64. - texsize.Y);

 
        // Physics
        v3f velocity((rand() % 100 / 50. - 1) / 1.5,
 
        // Physics
        v3f velocity((rand() % 100 / 50. - 1) / 1.5,


@@ -559,15 +650,18 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
                visual_size,
                true,
                false,
                visual_size,
                true,
                false,

+               false,

                texture,
                texpos,
                texture,
                texpos,

-               texsize);
+               texsize,
+               anim,
+               0);

 
        addParticle(toadd);
 }
 
 void ParticleManager::addParticle(Particle* toadd)
 {
 
        addParticle(toadd);
 }
 
 void ParticleManager::addParticle(Particle* toadd)
 {

-       JMutexAutoLock lock(m_particle_list_lock);
+       MutexAutoLock lock(m_particle_list_lock);

        m_particles.push_back(toadd);
 }
        m_particles.push_back(toadd);
 }