]> git.lizzy.rs Git - dragonfireclient.git/blobdiff - src/particles.cpp
Sound: Add pitch option (#5960)
[dragonfireclient.git] / src / particles.cpp
index 5f17763e013373cf2ef4423facbb1122635496fe..e89e182e685cb99a11982657177750a72514e1fe 100644 (file)
@@ -27,6 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "clientmap.h"
 #include "mapnode.h"
 #include "client.h"
+#include "settings.h"
 
 /*
        Utility
@@ -56,7 +57,8 @@ Particle::Particle(
        v2f texpos,
        v2f texsize,
        const struct TileAnimationParams &anim,
-       u8 glow
+       u8 glow,
+       video::SColor color
 ):
        scene::ISceneNode(smgr->getRootSceneNode(), smgr)
 {
@@ -77,6 +79,10 @@ Particle::Particle(
        m_animation_frame = 0;
        m_animation_time = 0.0;
 
+       // Color
+       m_base_color = color;
+       m_color = color;
+
        // Particle related
        m_pos = pos;
        m_velocity = velocity;
@@ -183,12 +189,15 @@ void Particle::updateLight()
        else
                light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
 
-       m_light = decode_light(light + m_glow);
+       u8 m_light = decode_light(light + m_glow);
+       m_color.set(255,
+               m_light * m_base_color.getRed() / 255,
+               m_light * m_base_color.getGreen() / 255,
+               m_light * m_base_color.getBlue() / 255);
 }
 
 void Particle::updateVertices()
 {
-       video::SColor c(255, m_light, m_light, m_light);
        f32 tx0, tx1, ty0, ty1;
 
        if (m_animation.type != TAT_NONE) {
@@ -210,14 +219,14 @@ void Particle::updateVertices()
                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[1] = video::S3DVertex(m_size/2,-m_size/2,0, 0,0,0,
-                       c, tx1, ty1);
-       m_vertices[2] = video::S3DVertex(m_size/2,m_size/2,0, 0,0,0,
-                       c, tx1, ty0);
-       m_vertices[3] = video::S3DVertex(-m_size/2,m_size/2,0, 0,0,0,
-                       c, tx0, ty0);
+       m_vertices[0] = video::S3DVertex(-m_size / 2, -m_size / 2,
+               0, 0, 0, 0, m_color, tx0, ty1);
+       m_vertices[1] = video::S3DVertex(m_size / 2, -m_size / 2,
+               0, 0, 0, 0, m_color, tx1, ty1);
+       m_vertices[2] = video::S3DVertex(m_size / 2, m_size / 2,
+               0, 0, 0, 0, m_color, tx1, ty0);
+       m_vertices[3] = video::S3DVertex(-m_size / 2, m_size / 2,
+               0, 0, 0, 0, m_color, tx0, ty0);
 
        v3s16 camera_offset = m_env->getCameraOffset();
        for(u16 i=0; i<4; i++)
@@ -285,6 +294,9 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
 {
        m_time += dtime;
 
+       static const float radius =
+                       g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE;
+
        bool unloaded = false;
        bool is_attached = false;
        v3f attached_pos = v3f(0,0,0);
@@ -308,11 +320,74 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
                        {
                                m_amount--;
 
-                               // Pretend to, but don't actually spawn a
-                               // particle if it is attached to an unloaded
-                               // object.
+                               // Pretend to, but don't actually spawn a particle if it is
+                               // attached to an unloaded object or distant from player.
                                if (!unloaded) {
+                                       v3f ppos = m_player->getPosition() / BS;
                                        v3f pos = random_v3f(m_minpos, m_maxpos);
+
+                                       if (pos.getDistanceFrom(ppos) <= radius) {
+                                               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;
+                       }
+               }
+       }
+       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)
+                       {
+                               // Do not spawn particle if distant from player
+                               v3f ppos = m_player->getPosition() / BS;
+                               v3f pos = random_v3f(m_minpos, m_maxpos);
+
+                               if (pos.getDistanceFrom(ppos) <= radius) {
                                        v3f vel = random_v3f(m_minvel, m_maxvel);
                                        v3f acc = random_v3f(m_minacc, m_maxacc);
 
@@ -351,61 +426,6 @@ void ParticleSpawner::step(float dtime, ClientEnvironment* env)
                                                m_glow);
                                        m_particlemanager->addParticle(toadd);
                                }
-                               i = m_spawntimes.erase(i);
-                       }
-                       else
-                       {
-                               ++i;
-                       }
-               }
-       }
-       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)
-                       {
-                               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);
                        }
                }
        }
@@ -589,35 +609,39 @@ void ParticleManager::handleParticleEvent(ClientEvent *event, Client *client,
        }
 }
 
-void ParticleManager::addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
-               LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleManager::addDiggingParticles(IGameDef* gamedef,
+       scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos,
+       const MapNode &n, const ContentFeatures &f)
 {
        for (u16 j = 0; j < 32; j++) // set the amount of particles here
        {
-               addNodeParticle(gamedef, smgr, player, pos, tiles);
+               addNodeParticle(gamedef, smgr, player, pos, n, f);
        }
 }
 
-void ParticleManager::addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
-               LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleManager::addPunchingParticles(IGameDef* gamedef,
+       scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos,
+       const MapNode &n, const ContentFeatures &f)
 {
-       addNodeParticle(gamedef, smgr, player, pos, tiles);
+       addNodeParticle(gamedef, smgr, player, pos, n, f);
 }
 
-void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
-               LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleManager::addNodeParticle(IGameDef* gamedef,
+       scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos,
+       const MapNode &n, const ContentFeatures &f)
 {
        // Texture
        u8 texid = myrand_range(0, 5);
+       const TileLayer &tile = f.tiles[texid].layers[0];
        video::ITexture *texture;
        struct TileAnimationParams anim;
        anim.type = TAT_NONE;
 
        // Only use first frame of animated texture
-       if (tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION)
-               texture = tiles[texid].frames[0].texture;
+       if (tile.material_flags & MATERIAL_FLAG_ANIMATION)
+               texture = tile.frames[0].texture;
        else
-               texture = tiles[texid].texture;
+               texture = tile.texture;
 
        float size = rand() % 64 / 512.;
        float visual_size = BS * size;
@@ -638,6 +662,12 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
                (f32) pos.Z + rand() %100 /200. - 0.25
        );
 
+       video::SColor color;
+       if (tile.has_color)
+               color = tile.color;
+       else
+               n.getColor(f, &color);
+
        Particle* toadd = new Particle(
                gamedef,
                smgr,
@@ -655,7 +685,8 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
                texpos,
                texsize,
                anim,
-               0);
+               0,
+               color);
 
        addParticle(toadd);
 }