449 lines
10 KiB
C++
449 lines
10 KiB
C++
/************************************************************************
|
|
* Minetest-c55
|
|
* Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
*
|
|
* particles.cpp
|
|
* voxelands - 3d voxel world sandbox game
|
|
* Copyright (C) Lisa 'darkrose' Milne 2014 <lisa@ltmnet.com>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*
|
|
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
|
* for Voxelands.
|
|
************************************************************************/
|
|
|
|
#include "particles.h"
|
|
#include "constants.h"
|
|
#include "debug.h"
|
|
#include "main.h"
|
|
#include "tile.h"
|
|
#include "collision.h"
|
|
#include <stdlib.h>
|
|
#include "utility.h"
|
|
#include "light.h"
|
|
#include "environment.h"
|
|
#include "map.h"
|
|
#include "mapnode.h"
|
|
|
|
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(
|
|
scene::ISceneManager* smgr,
|
|
LocalPlayer *player,
|
|
s32 id,
|
|
v3f pos,
|
|
v3f velocity,
|
|
v3f acceleration,
|
|
float expirationtime,
|
|
float size,
|
|
AtlasPointer *ap
|
|
):
|
|
scene::ISceneNode(smgr->getRootSceneNode(), smgr, id)
|
|
{
|
|
m_camera_offset = v3s16(0,0,0);
|
|
|
|
// Texture
|
|
m_material.setFlag(video::EMF_LIGHTING, false);
|
|
m_material.setFlag(video::EMF_BACK_FACE_CULLING, 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;
|
|
|
|
// Particle related
|
|
m_pos = pos;
|
|
m_velocity = velocity;
|
|
m_acceleration = acceleration;
|
|
m_expiration = expirationtime;
|
|
m_time = 0;
|
|
m_player = player;
|
|
m_size = size;
|
|
|
|
// Irrlicht stuff (TODO)
|
|
m_collisionbox = core::aabbox3d<f32>(-size/2,-size/2,-size/2,size/2,size/2,size/2);
|
|
this->setAutomaticCulling(scene::EAC_OFF);
|
|
}
|
|
|
|
Particle::~Particle()
|
|
{
|
|
delete m_ap;
|
|
}
|
|
|
|
void Particle::OnRegisterSceneNode()
|
|
{
|
|
if (IsVisible) {
|
|
SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
|
|
SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
|
|
}
|
|
|
|
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);
|
|
|
|
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, 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.getMap(),
|
|
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;
|
|
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());
|
|
}
|
|
catch(InvalidPositionException &e){
|
|
light = blend_light(env.getDayNightRatio(), LIGHT_SUN, 0);
|
|
}
|
|
m_light = decode_light(light);
|
|
|
|
video::SColor c(255, m_light, m_light, m_light);
|
|
|
|
m_vertices[0] = video::S3DVertex(-m_size/2,-m_size/2,0, 0,0,0,
|
|
c, m_ap->x0(), m_ap->y1());
|
|
m_vertices[1] = video::S3DVertex(m_size/2,-m_size/2,0, 0,0,0,
|
|
c, m_ap->x1(), m_ap->y1());
|
|
m_vertices[2] = video::S3DVertex(m_size/2,m_size/2,0, 0,0,0,
|
|
c, m_ap->x1(), m_ap->y0());
|
|
m_vertices[3] = video::S3DVertex(-m_size/2,m_size/2,0, 0,0,0,
|
|
c, m_ap->x0(), m_ap->y0());
|
|
|
|
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 - intToFloat(m_camera_offset, BS);
|
|
}
|
|
}
|
|
|
|
std::vector<Particle*> all_particles;
|
|
std::map<u32, ParticleSpawner*> all_particlespawners;
|
|
u32 particle_spawner_ids = 1;
|
|
|
|
void allparticles_step (float dtime, ClientEnvironment &env)
|
|
{
|
|
for (std::vector<Particle*>::iterator i = all_particles.begin(); i != all_particles.end();) {
|
|
if ((*i)->get_expired()) {
|
|
(*i)->remove();
|
|
delete *i;
|
|
all_particles.erase(i);
|
|
}else{
|
|
(*i)->step(dtime, env);
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void addDiggingParticles(scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
|
|
{
|
|
for (u16 j=0; j<DIGGING_PARTICLES_AMOUNT; j++) {
|
|
addNodeParticle(smgr, player, pos, tiles);
|
|
}
|
|
}
|
|
|
|
void addPunchingParticles(scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
|
|
{
|
|
addNodeParticle(smgr, player, pos, tiles);
|
|
}
|
|
|
|
// add a particle of a node
|
|
// used by digging and punching particles
|
|
void addNodeParticle(scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
|
|
{
|
|
// Texture
|
|
u8 texid = myrand_range(0,5);
|
|
AtlasPointer *ap = new AtlasPointer(tiles[texid].texture);
|
|
float size = rand()%64/512.;
|
|
float visual_size = BS*size;
|
|
float texsize = size*2;
|
|
|
|
float x1 = ap->x1();
|
|
float y1 = ap->y1();
|
|
|
|
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);
|
|
|
|
// 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
|
|
);
|
|
|
|
Particle *particle = new Particle(
|
|
smgr,
|
|
player,
|
|
0,
|
|
particlepos,
|
|
velocity,
|
|
acceleration,
|
|
rand()%100/100., // expiration time
|
|
visual_size,
|
|
ap);
|
|
|
|
all_particles.push_back(particle);
|
|
}
|
|
|
|
/*
|
|
ParticleSpawner
|
|
*/
|
|
|
|
ParticleSpawner::ParticleSpawner(
|
|
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,
|
|
AtlasPointer *ap,
|
|
u32 id
|
|
)
|
|
{
|
|
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_ap = ap;
|
|
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);
|
|
}
|
|
|
|
all_particlespawners.insert(std::pair<u32, ParticleSpawner*>(id, this));
|
|
}
|
|
|
|
ParticleSpawner::~ParticleSpawner() {}
|
|
|
|
void ParticleSpawner::step(float dtime, ClientEnvironment &env)
|
|
{
|
|
m_time += dtime;
|
|
|
|
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;
|
|
|
|
new Particle(
|
|
m_smgr,
|
|
m_player,
|
|
0,
|
|
pos,
|
|
vel,
|
|
acc,
|
|
exptime,
|
|
size,
|
|
m_ap
|
|
);
|
|
m_spawntimes.erase(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_smgr,
|
|
m_player,
|
|
0,
|
|
pos,
|
|
vel,
|
|
acc,
|
|
exptime,
|
|
size,
|
|
m_ap
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void allparticlespawners_step (float dtime, ClientEnvironment &env)
|
|
{
|
|
for (std::map<u32, ParticleSpawner*>::iterator i = all_particlespawners.begin(); i != all_particlespawners.end();) {
|
|
if (i->second->get_expired()) {
|
|
delete i->second;
|
|
all_particlespawners.erase(i++);
|
|
}else{
|
|
i->second->step(dtime, env);
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void delete_particlespawner (u32 id)
|
|
{
|
|
std::map<u32, ParticleSpawner*>::iterator i = all_particlespawners.find(id);
|
|
if (i == all_particlespawners.end())
|
|
return;
|
|
|
|
delete i->second;
|
|
all_particlespawners.erase(id);
|
|
}
|
|
|
|
u32 add_particlespawner(
|
|
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,
|
|
AtlasPointer *ap
|
|
)
|
|
{
|
|
u32 id = particle_spawner_ids++;
|
|
ParticleSpawner *p = new ParticleSpawner(
|
|
smgr,
|
|
player,
|
|
amount,
|
|
time,
|
|
minpos,
|
|
maxpos,
|
|
minvel,
|
|
maxvel,
|
|
minacc,
|
|
maxacc,
|
|
minexptime,
|
|
maxexptime,
|
|
minsize,
|
|
maxsize,
|
|
false,
|
|
ap,
|
|
id
|
|
);
|
|
|
|
if (p == NULL)
|
|
return 0;
|
|
|
|
return id;
|
|
}
|
|
|
|
void clear_particles ()
|
|
{
|
|
for (std::map<u32, ParticleSpawner*>::iterator i = all_particlespawners.begin(); i != all_particlespawners.end();)
|
|
{
|
|
delete i->second;
|
|
all_particlespawners.erase(i++);
|
|
}
|
|
|
|
for (std::vector<Particle*>::iterator i = all_particles.begin(); i != all_particles.end();)
|
|
{
|
|
(*i)->remove();
|
|
delete *i;
|
|
all_particles.erase(i);
|
|
}
|
|
}
|
|
|
|
void update_particles_camera_offset(v3s16 camera_offset)
|
|
{
|
|
for (std::vector<Particle*>::iterator i = all_particles.begin(); i != all_particles.end(); i++) {
|
|
(*i)->updateCameraOffset(camera_offset);
|
|
}
|
|
}
|