X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fparticles.cpp;h=0a6651ce453624a68c1a02b034cfe735480f3bca;hb=c7c03ad7a60b77040d0dfc360a79f065e0c2c971;hp=ce5a4013fc5efed6e3907021be289c041879f144;hpb=a5377251e213803f61752594b7b52d31ac410bb2;p=dragonfireclient.git diff --git a/src/particles.cpp b/src/particles.cpp index ce5a4013f..0a6651ce4 100644 --- a/src/particles.cpp +++ b/src/particles.cpp @@ -18,19 +18,18 @@ with this program; if not, write to the Free Software Foundation, Inc., */ #include "particles.h" -#include "constants.h" -#include "debug.h" -#include "main.h" // For g_profiler and g_settings -#include "settings.h" -#include "tile.h" -#include "gamedef.h" +#include "client.h" #include "collision.h" -#include +#include "client/clientevent.h" +#include "client/renderingengine.h" #include "util/numeric.h" #include "light.h" #include "environment.h" #include "clientmap.h" #include "mapnode.h" +#include "nodedef.h" +#include "client.h" +#include "settings.h" /* Utility @@ -43,28 +42,31 @@ v3f random_v3f(v3f min, v3f max) rand()/(float)RAND_MAX*(max.Z-min.Z)+min.Z); } -std::vector all_particles; -std::map all_particlespawners; - Particle::Particle( IGameDef *gamedef, - scene::ISceneManager* smgr, LocalPlayer *player, - ClientEnvironment &env, + ClientEnvironment *env, v3f pos, v3f velocity, v3f acceleration, float expirationtime, float size, bool collisiondetection, + bool collision_removal, + bool vertical, video::ITexture *texture, v2f texpos, - v2f texsize + v2f texsize, + const struct TileAnimationParams &anim, + u8 glow, + video::SColor color ): - scene::ISceneNode(smgr->getRootSceneNode(), smgr) + scene::ISceneNode(RenderingEngine::get_scene_manager()->getRootSceneNode(), + RenderingEngine::get_scene_manager()) { // Misc m_gamedef = gamedef; + m_env = env; // Texture m_material.setFlag(video::EMF_LIGHTING, false); @@ -75,53 +77,46 @@ Particle::Particle( m_material.setTexture(0, texture); m_texpos = texpos; m_texsize = texsize; + m_animation = anim; + // Color + m_base_color = color; + m_color = color; // Particle related m_pos = pos; m_velocity = velocity; m_acceleration = acceleration; m_expiration = expirationtime; - m_time = 0; m_player = player; m_size = size; m_collisiondetection = collisiondetection; + m_collision_removal = collision_removal; + m_vertical = vertical; + m_glow = glow; // Irrlicht stuff - m_collisionbox = core::aabbox3d + m_collisionbox = aabb3f (-size/2,-size/2,-size/2,size/2,size/2,size/2); this->setAutomaticCulling(scene::EAC_OFF); // Init lighting - updateLight(env); + updateLight(); // Init model updateVertices(); - - all_particles.push_back(this); -} - -Particle::~Particle() -{ } void Particle::OnRegisterSceneNode() { if (IsVisible) - { - SceneManager->registerNodeForRendering - (this, scene::ESNRP_TRANSPARENT); - SceneManager->registerNodeForRendering - (this, scene::ESNRP_SOLID); - } + SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT_EFFECT); ISceneNode::OnRegisterSceneNode(); } void Particle::render() { - // TODO: Render particles in front of water and the selectionbox - video::IVideoDriver* driver = SceneManager->getVideoDriver(); driver->setMaterial(m_material); driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); @@ -132,184 +127,131 @@ void Particle::render() scene::EPT_TRIANGLES, video::EIT_16BIT); } -void Particle::step(float dtime, ClientEnvironment &env) +void Particle::step(float dtime) { m_time += dtime; - if (m_collisiondetection) - { - core::aabbox3d box = m_collisionbox; - v3f p_pos = m_pos*BS; - v3f p_velocity = m_velocity*BS; - v3f p_acceleration = m_acceleration*BS; - collisionMoveSimple(&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; } + 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(env); + updateLight(); // Update model updateVertices(); } -void Particle::updateLight(ClientEnvironment &env) +void Particle::updateLight() { u8 light = 0; - try{ - v3s16 p = v3s16( - floor(m_pos.X+0.5), - floor(m_pos.Y+0.5), - floor(m_pos.Z+0.5) - ); - MapNode n = env.getClientMap().getNode(p); - light = n.getLightBlend(env.getDayNightRatio(), m_gamedef->ndef()); - } - catch(InvalidPositionException &e){ - light = blend_light(env.getDayNightRatio(), LIGHT_SUN, 0); - } - m_light = decode_light(light); + bool pos_ok; + + v3s16 p = v3s16( + floor(m_pos.X+0.5), + floor(m_pos.Y+0.5), + floor(m_pos.Z+0.5) + ); + MapNode n = m_env->getClientMap().getNodeNoEx(p, &pos_ok); + if (pos_ok) + light = n.getLightBlend(m_env->getDayNightRatio(), m_gamedef->ndef()); + else + light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0); + + 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 = m_texpos.X; - f32 tx1 = m_texpos.X + m_texsize.X; - f32 ty0 = m_texpos.Y; - f32 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); - - for(u16 i=0; i<4; i++) - { - m_vertices[i].Pos.rotateYZBy(m_player->getPitch()); - m_vertices[i].Pos.rotateXZBy(m_player->getYaw()); - m_box.addInternalPoint(m_vertices[i].Pos); - m_vertices[i].Pos += m_pos*BS; + 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; } -} - -/* - Helpers -*/ - - -void allparticles_step (float dtime, ClientEnvironment &env) -{ - for(std::vector::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, env); - i++; + 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 (video::S3DVertex &vertex : m_vertices) { + if (m_vertical) { + v3f ppos = m_player->getPosition()/BS; + vertex.Pos.rotateXZBy(atan2(ppos.Z-m_pos.Z, ppos.X-m_pos.X)/core::DEGTORAD+90); + } else { + vertex.Pos.rotateYZBy(m_player->getPitch()); + vertex.Pos.rotateXZBy(m_player->getYaw()); } + m_box.addInternalPoint(vertex.Pos); + vertex.Pos += m_pos*BS - intToFloat(camera_offset, BS); } } -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, - texture, - texpos, - texsize); -} - /* ParticleSpawner */ -ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr, LocalPlayer *player, +ParticleSpawner::ParticleSpawner(IGameDef *gamedef, LocalPlayer *player, 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, 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) { m_gamedef = gamedef; - m_smgr = smgr; m_player = player; m_amount = amount; m_spawntime = time; @@ -324,144 +266,387 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr, 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_animation = anim; + m_glow = glow; for (u16 i = 0; i<=m_amount; i++) { float spawntime = (float)rand()/(float)RAND_MAX*m_spawntime; m_spawntimes.push_back(spawntime); } - - all_particlespawners.insert(std::pair(id, this)); } -ParticleSpawner::~ParticleSpawner() {} +void ParticleSpawner::spawnParticle(ClientEnvironment *env, float radius, + bool is_attached, const v3f &attached_pos, float attached_yaw) +{ + v3f ppos = m_player->getPosition() / BS; + v3f pos = random_v3f(m_minpos, m_maxpos); + + // Need to apply this first or the following check + // will be wrong for attached spawners + if (is_attached) { + pos.rotateXZBy(attached_yaw); + pos += attached_pos; + } + + if (pos.getDistanceFrom(ppos) > radius) + return; -void ParticleSpawner::step(float dtime, ClientEnvironment &env) + v3f vel = random_v3f(m_minvel, m_maxvel); + v3f acc = random_v3f(m_minacc, m_maxacc); + + if (is_attached) { + // Apply attachment yaw + 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; + + m_particlemanager->addParticle(new Particle( + m_gamedef, + 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 + )); +} + +void ParticleSpawner::step(float dtime, ClientEnvironment* env) { m_time += dtime; - if (m_spawntime != 0) // Spawner exists for a predefined timespan - { - for(std::vector::iterator i = m_spawntimes.begin(); - i != m_spawntimes.end();) - { - if ((*i) <= m_time && m_amount > 0) - { + static thread_local 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); + 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::iterator i = m_spawntimes.begin(); + i != m_spawntimes.end();) { + if ((*i) <= m_time && m_amount > 0) { 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; - - new Particle( - m_gamedef, - m_smgr, - m_player, - env, - pos, - vel, - acc, - exptime, - size, - m_collisiondetection, - m_texture, - v2f(0.0, 0.0), - v2f(1.0, 1.0)); + // Pretend to, but don't actually spawn a particle if it is + // attached to an unloaded object or distant from player. + if (!unloaded) + spawnParticle(env, radius, is_attached, attached_pos, attached_yaw); + i = m_spawntimes.erase(i); - } - else - { - i++; + } else { + ++i; } } - } - else // Spawner exists for an infinity timespan, spawn on a per-second base - { - 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); - float exptime = rand()/(float)RAND_MAX - *(m_maxexptime-m_minexptime) - +m_minexptime; - float size = rand()/(float)RAND_MAX - *(m_maxsize-m_minsize) - +m_minsize; - - new Particle( - m_gamedef, - m_smgr, - m_player, - env, - pos, - vel, - acc, - exptime, - size, - m_collisiondetection, - m_texture, - v2f(0.0, 0.0), - v2f(1.0, 1.0)); - } + } 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) + spawnParticle(env, radius, is_attached, attached_pos, attached_yaw); } } } -void allparticlespawners_step (float dtime, ClientEnvironment &env) + +ParticleManager::ParticleManager(ClientEnvironment* env) : + m_env(env) +{} + +ParticleManager::~ParticleManager() { - for(std::map::iterator i = - all_particlespawners.begin(); - i != all_particlespawners.end();) + clearAll(); +} + +void ParticleManager::step(float dtime) +{ + stepParticles (dtime); + stepSpawners (dtime); +} + +void ParticleManager::stepSpawners (float dtime) +{ + MutexAutoLock lock(m_spawner_list_lock); + for (std::map::iterator i = + 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++; + 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()) + MutexAutoLock lock(m_particle_list_lock); + for(std::vector::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 () { + MutexAutoLock lock(m_spawner_list_lock); + MutexAutoLock lock2(m_particle_list_lock); for(std::map::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::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, Client *client, + LocalPlayer *player) +{ + 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; + } + 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); + } + } + + video::ITexture *texture = + client->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture)); + + ParticleSpawner *toadd = new ParticleSpawner(client, 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; + + { + MutexAutoLock lock(m_spawner_list_lock); + m_particle_spawners.insert( + std::pair( + event->add_particlespawner.id, + toadd)); + } + break; + } + case CE_SPAWN_PARTICLE: { + video::ITexture *texture = + client->tsrc()->getTextureForMesh(*(event->spawn_particle.texture)); + + Particle *toadd = new Particle(client, 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); + + addParticle(toadd); + + delete event->spawn_particle.pos; + delete event->spawn_particle.vel; + delete event->spawn_particle.acc; + delete event->spawn_particle.texture; + + break; + } + default: break; + } +} + +void ParticleManager::addDiggingParticles(IGameDef* gamedef, + LocalPlayer *player, v3s16 pos, const MapNode &n, const ContentFeatures &f) +{ + // No particles for "airlike" nodes + if (f.drawtype == NDT_AIRLIKE) + return; + + // set the amount of particles here + for (u16 j = 0; j < 32; j++) { + addNodeParticle(gamedef, player, pos, n, f); } } + +void ParticleManager::addNodeParticle(IGameDef* gamedef, + LocalPlayer *player, v3s16 pos, const MapNode &n, const ContentFeatures &f) +{ + // No particles for "airlike" nodes + if (f.drawtype == NDT_AIRLIKE) + return; + + // 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 (tile.material_flags & MATERIAL_FLAG_ANIMATION) + texture = (*tile.frames)[0].texture; + else + texture = tile.texture; + + float size = rand() % 64 / 512.; + float visual_size = BS * size; + if (tile.scale) + size /= tile.scale; + v2f texsize(size * 2, size * 2); + v2f texpos; + texpos.X = ((rand() % 64) / 64. - texsize.X); + texpos.Y = ((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 + ); + + video::SColor color; + if (tile.has_color) + color = tile.color; + else + n.getColor(f, &color); + + Particle* toadd = new Particle( + gamedef, + player, + m_env, + particlepos, + velocity, + acceleration, + rand() % 100 / 100., // expiration time + visual_size, + true, + false, + false, + texture, + texpos, + texsize, + anim, + 0, + color); + + addParticle(toadd); +} + +void ParticleManager::addParticle(Particle* toadd) +{ + MutexAutoLock lock(m_particle_list_lock); + m_particles.push_back(toadd); +}