#include "environment.h"
#include "clientmap.h"
#include "mapnode.h"
+#include "client.h"
+
+/*
+ Utility
+*/
+
+v3f random_v3f(v3f min, v3f max)
+{
+ return v3f( rand()/(float)RAND_MAX*(max.X-min.X)+min.X,
+ rand()/(float)RAND_MAX*(max.Y-min.Y)+min.Y,
+ rand()/(float)RAND_MAX*(max.Z-min.Z)+min.Z);
+}
Particle::Particle(
IGameDef *gamedef,
scene::ISceneManager* smgr,
LocalPlayer *player,
- s32 id,
+ ClientEnvironment *env,
v3f pos,
v3f velocity,
v3f acceleration,
float expirationtime,
float size,
- AtlasPointer ap
+ bool collisiondetection,
+ bool vertical,
+ video::ITexture *texture,
+ v2f texpos,
+ v2f texsize
):
- scene::ISceneNode(smgr->getRootSceneNode(), smgr, id)
+ scene::ISceneNode(smgr->getRootSceneNode(), smgr)
{
// Misc
m_gamedef = gamedef;
+ m_env = env;
// Texture
m_material.setFlag(video::EMF_LIGHTING, false);
m_material.setFlag(video::EMF_BILINEAR_FILTER, false);
m_material.setFlag(video::EMF_FOG_ENABLE, true);
m_material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- m_material.setTexture(0, ap.atlas);
- m_ap = ap;
- m_light = 0;
+ m_material.setTexture(0, texture);
+ m_texpos = texpos;
+ m_texsize = texsize;
// Particle related
m_time = 0;
m_player = player;
m_size = size;
+ m_collisiondetection = collisiondetection;
+ m_vertical = vertical;
- // Irrlicht stuff (TODO)
- m_collisionbox = core::aabbox3d<f32>(-size/2,-size/2,-size/2,size/2,size/2,size/2);
+ // Irrlicht stuff
+ m_collisionbox = core::aabbox3d<f32>
+ (-size/2,-size/2,-size/2,size/2,size/2,size/2);
this->setAutomaticCulling(scene::EAC_OFF);
+
+ // Init lighting
+ updateLight();
+
+ // Init model
+ updateVertices();
}
Particle::~Particle()
{
if (IsVisible)
{
- SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
- SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
+ SceneManager->registerNodeForRendering
+ (this, scene::ESNRP_TRANSPARENT);
+ SceneManager->registerNodeForRendering
+ (this, scene::ESNRP_SOLID);
}
ISceneNode::OnRegisterSceneNode();
video::IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(m_material);
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
- video::SColor c(255, m_light, m_light, m_light);
- video::S3DVertex vertices[4] =
+ u16 indices[] = {0,1,2, 2,3,0};
+ driver->drawVertexPrimitiveList(m_vertices, 4,
+ indices, 2, video::EVT_STANDARD,
+ scene::EPT_TRIANGLES, video::EIT_16BIT);
+}
+
+void Particle::step(float dtime)
+{
+ m_time += dtime;
+ if (m_collisiondetection)
{
- video::S3DVertex(-m_size/2,-m_size/2,0, 0,0,0, c, m_ap.x0(), m_ap.y1()),
- video::S3DVertex(m_size/2,-m_size/2,0, 0,0,0, c, m_ap.x1(), m_ap.y1()),
- video::S3DVertex(m_size/2,m_size/2,0, 0,0,0, c, m_ap.x1(), m_ap.y0()),
- video::S3DVertex(-m_size/2,m_size/2,0, 0,0,0, c ,m_ap.x0(), m_ap.y0()),
- };
+ 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
+ {
+ m_velocity += m_acceleration * dtime;
+ m_pos += m_velocity * dtime;
+ }
+
+ // Update lighting
+ updateLight();
+
+ // Update model
+ updateVertices();
+}
+
+void Particle::updateLight()
+{
+ u8 light = 0;
+ 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);
+
+ m_light = decode_light(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;
+
+ 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);
+
+ v3s16 camera_offset = m_env->getCameraOffset();
for(u16 i=0; i<4; i++)
{
- vertices[i].Pos.rotateYZBy(m_player->getPitch());
- vertices[i].Pos.rotateXZBy(m_player->getYaw());
- m_box.addInternalPoint(vertices[i].Pos);
- vertices[i].Pos += m_pos*BS;
+ if (m_vertical) {
+ v3f ppos = m_player->getPosition()/BS;
+ m_vertices[i].Pos.rotateXZBy(atan2(ppos.Z-m_pos.Z, ppos.X-m_pos.X)/core::DEGTORAD+90);
+ } else {
+ 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 - intToFloat(camera_offset, BS);
}
+}
- u16 indices[] = {0,1,2, 2,3,0};
- driver->drawVertexPrimitiveList(vertices, 4, indices, 2,
- video::EVT_STANDARD, scene::EPT_TRIANGLES, video::EIT_16BIT);
-}
-
-void Particle::step(float dtime, ClientEnvironment &env)
-{
- 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(&env.getClientMap(), 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;
+/*
+ ParticleSpawner
+*/
+
+ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr, 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, bool vertical, video::ITexture *texture, u32 id,
+ ParticleManager *p_manager) :
+ m_particlemanager(p_manager)
+{
+ m_gamedef = gamedef;
+ m_smgr = smgr;
+ m_player = player;
+ m_amount = amount;
+ m_spawntime = time;
+ m_minpos = minpos;
+ m_maxpos = maxpos;
+ m_minvel = minvel;
+ m_maxvel = maxvel;
+ m_minacc = minacc;
+ m_maxacc = maxacc;
+ m_minexptime = minexptime;
+ m_maxexptime = maxexptime;
+ m_minsize = minsize;
+ m_maxsize = maxsize;
+ m_collisiondetection = collisiondetection;
+ m_vertical = vertical;
+ m_texture = texture;
+ m_time = 0;
+
+ for (u16 i = 0; i<=m_amount; i++)
+ {
+ float spawntime = (float)rand()/(float)RAND_MAX*m_spawntime;
+ m_spawntimes.push_back(spawntime);
+ }
+}
+
+ParticleSpawner::~ParticleSpawner() {}
+
+void ParticleSpawner::step(float dtime, ClientEnvironment* env)
+{
m_time += dtime;
- // Update lighting
- 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());
+ if (m_spawntime != 0) // Spawner exists for a predefined timespan
+ {
+ for(std::vector<float>::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;
+
+ 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);
+ i = m_spawntimes.erase(i);
+ }
+ else
+ {
+ i++;
+ }
+ }
}
- catch(InvalidPositionException &e){
- light = blend_light(env.getDayNightRatio(), LIGHT_SUN, 0);
+ 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_vertical,
+ m_texture,
+ v2f(0.0, 0.0),
+ v2f(1.0, 1.0));
+ }
+ }
}
- m_light = decode_light(light);
}
-std::vector<Particle*> all_particles;
-void allparticles_step (float dtime, ClientEnvironment &env)
+ParticleManager::ParticleManager(ClientEnvironment* env) :
+ m_env(env)
+{}
+
+ParticleManager::~ParticleManager()
+{
+ clearAll();
+}
+
+void ParticleManager::step(float dtime)
{
- for(std::vector<Particle*>::iterator i = all_particles.begin(); i != all_particles.end();)
+ stepParticles (dtime);
+ stepSpawners (dtime);
+}
+
+void ParticleManager::stepSpawners (float dtime)
+{
+ JMutexAutoLock lock(m_spawner_list_lock);
+ for(std::map<u32, ParticleSpawner*>::iterator i =
+ m_particle_spawners.begin();
+ i != m_particle_spawners.end();)
+ {
+ if (i->second->get_expired())
+ {
+ delete i->second;
+ m_particle_spawners.erase(i++);
+ }
+ else
+ {
+ i->second->step(dtime, m_env);
+ i++;
+ }
+ }
+}
+
+void ParticleManager::stepParticles (float dtime)
+{
+ JMutexAutoLock lock(m_particle_list_lock);
+ for(std::vector<Particle*>::iterator i = m_particles.begin();
+ i != m_particles.end();)
{
if ((*i)->get_expired())
{
(*i)->remove();
delete *i;
- all_particles.erase(i);
+ i = m_particles.erase(i);
}
else
{
- (*i)->step(dtime, env);
+ (*i)->step(dtime);
i++;
}
}
}
-void addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleManager::clearAll ()
+{
+ JMutexAutoLock lock(m_spawner_list_lock);
+ JMutexAutoLock lock2(m_particle_list_lock);
+ for(std::map<u32, ParticleSpawner*>::iterator i =
+ m_particle_spawners.begin();
+ i != m_particle_spawners.end();)
+ {
+ delete i->second;
+ m_particle_spawners.erase(i++);
+ }
+
+ for(std::vector<Particle*>::iterator i =
+ m_particles.begin();
+ i != m_particles.end();)
+ {
+ (*i)->remove();
+ delete *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->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 =
+ 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->add_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
{
}
}
-void 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 TileSpec tiles[])
{
addNodeParticle(gamedef, smgr, player, pos, tiles);
}
-// add a particle of a node
-// used by digging and punching particles
-void 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 TileSpec tiles[])
{
// Texture
- u8 texid = myrand_range(0,5);
- AtlasPointer ap = tiles[texid].texture;
- float size = rand()%64/512.;
- float visual_size = BS*size;
- float texsize = size*2;
+ u8 texid = myrand_range(0, 5);
+ video::ITexture *texture = tiles[texid].texture;
- float x1 = ap.x1();
- float y1 = ap.y1();
+ // 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;
- ap.size.X = (ap.x1() - ap.x0()) * texsize;
- ap.size.Y = (ap.x1() - ap.x0()) * texsize;
-
- ap.pos.X = ap.x0() + (x1 - ap.x0()) * ((rand()%64)/64.-texsize);
- ap.pos.Y = ap.y0() + (y1 - ap.y0()) * ((rand()%64)/64.-texsize);
+ 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 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
+ (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 *particle = new Particle(
+ Particle* toadd = new Particle(
gamedef,
smgr,
player,
- 0,
+ m_env,
particlepos,
velocity,
acceleration,
- rand()%100/100., // expiration time
+ rand() % 100 / 100., // expiration time
visual_size,
- ap);
+ true,
+ false,
+ texture,
+ texpos,
+ texsize);
- all_particles.push_back(particle);
+ addParticle(toadd);
+}
+
+void ParticleManager::addParticle(Particle* toadd)
+{
+ JMutexAutoLock lock(m_particle_list_lock);
+ m_particles.push_back(toadd);
}
projects / oweals / minetest.git / blobdiff