add particle effects when digging
This commit is contained in:
darkrose
parent
9d981e14ba
commit
63991834a9
|
|
@ -157,6 +157,7 @@ set(minetest_SRCS
|
|||
keycode.cpp
|
||||
camera.cpp
|
||||
clouds.cpp
|
||||
particles.cpp
|
||||
clientobject.cpp
|
||||
guiMainMenu.cpp
|
||||
guiKeyChangeMenu.cpp
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||
#include "jmutex.h"
|
||||
#include <ostream>
|
||||
#include "clientobject.h"
|
||||
#include "particles.h"
|
||||
#include "utility.h" // For IntervalLimiter
|
||||
|
||||
struct MeshMakeData;
|
||||
|
|
@ -203,6 +204,8 @@ public:
|
|||
void sendRespawn();
|
||||
void sendWantCookie();
|
||||
|
||||
ClientEnvironment& getEnv() { return m_env; }
|
||||
|
||||
// locks envlock
|
||||
void removeNode(v3s16 p);
|
||||
// locks envlock
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@ void set_default_settings(Settings *settings)
|
|||
settings->setDefault("view_bobbing_amount", "1.0");
|
||||
settings->setDefault("enable_3d_clouds", "false");
|
||||
settings->setDefault("opaque_water", "false");
|
||||
settings->setDefault("enable_particles", "true");
|
||||
|
||||
// Server stuff
|
||||
// "map-dir" doesn't exist by default.
|
||||
|
|
|
|||
13
src/game.cpp
13
src/game.cpp
|
|
@ -1746,6 +1746,8 @@ void the_game(
|
|||
else
|
||||
{
|
||||
dig_time_complete = prop.time;
|
||||
if (g_settings->getBool("enable_particles"))
|
||||
addPunchingParticles(smgr, player, nodepos, content_features(n).tiles);
|
||||
}
|
||||
|
||||
if(dig_time_complete >= 0.001)
|
||||
|
|
@ -1770,6 +1772,9 @@ void the_game(
|
|||
client.clearTempMod(nodepos);
|
||||
client.removeNode(nodepos);
|
||||
|
||||
if (g_settings->getBool("enable_particles"))
|
||||
addDiggingParticles(smgr, player, nodepos, content_features(n).tiles);
|
||||
|
||||
dig_time = 0;
|
||||
|
||||
nodig_delay_counter = dig_time_complete
|
||||
|
|
@ -1932,6 +1937,12 @@ void the_game(
|
|||
0.05+brightness*0.95, farmesh_range);
|
||||
}
|
||||
|
||||
/*
|
||||
Update particles
|
||||
*/
|
||||
allparticles_step(dtime, client.getEnv());
|
||||
allparticlespawners_step(dtime, client.getEnv());
|
||||
|
||||
// Store brightness value
|
||||
old_brightness = brightness;
|
||||
|
||||
|
|
@ -2273,6 +2284,8 @@ void the_game(
|
|||
if(clouds)
|
||||
clouds->drop();
|
||||
|
||||
clear_particles();
|
||||
|
||||
/*
|
||||
Draw a "shutting down" screen, which will be shown while the map
|
||||
generator and other stuff quits
|
||||
|
|
|
|||
|
|
@ -84,6 +84,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
|
|||
bool smooth_lighting;
|
||||
bool clouds_3d;
|
||||
bool opaque_water;
|
||||
bool particles;
|
||||
|
||||
m_screensize = screensize;
|
||||
|
||||
|
|
@ -137,6 +138,13 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
|
|||
else
|
||||
opaque_water = m_data->opaque_water;
|
||||
}
|
||||
{
|
||||
gui::IGUIElement *e = getElementFromId(GUI_ID_PARTICLES_CB);
|
||||
if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
|
||||
particles = ((gui::IGUICheckBox*)e)->isChecked();
|
||||
else
|
||||
particles = m_data->particles;
|
||||
}
|
||||
|
||||
// Server options
|
||||
{
|
||||
|
|
@ -326,11 +334,17 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
|
|||
Environment->addCheckBox(opaque_water, rect, this, GUI_ID_OPAQUE_WATER_CB,
|
||||
wgettext("Opaque water"));
|
||||
}
|
||||
{
|
||||
core::rect<s32> rect(0, 0, 200, 30);
|
||||
rect += topleft_content + v2s32(85, 180);
|
||||
Environment->addCheckBox(particles, rect, this, GUI_ID_PARTICLES_CB,
|
||||
wgettext("Particles"));
|
||||
}
|
||||
|
||||
// Key change button
|
||||
{
|
||||
core::rect<s32> rect(0, 0, 130, 30);
|
||||
rect += topleft_content + v2s32(90, 200);
|
||||
rect += topleft_content + v2s32(90, 230);
|
||||
Environment->addButton(rect, this, GUI_ID_CHANGE_KEYS_BUTTON,
|
||||
wgettext("Change keys"));
|
||||
}
|
||||
|
|
@ -489,6 +503,11 @@ void GUIMainMenu::acceptInput()
|
|||
if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
|
||||
m_data->opaque_water = ((gui::IGUICheckBox*)e)->isChecked();
|
||||
}
|
||||
{
|
||||
gui::IGUIElement *e = getElementFromId(GUI_ID_PARTICLES_CB);
|
||||
if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
|
||||
m_data->particles = ((gui::IGUICheckBox*)e)->isChecked();
|
||||
}
|
||||
|
||||
m_accepted = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ enum {
|
|||
GUI_ID_SMOOTH_LIGHTING_CB,
|
||||
GUI_ID_3D_CLOUDS_CB,
|
||||
GUI_ID_OPAQUE_WATER_CB,
|
||||
GUI_ID_PARTICLES_CB,
|
||||
GUI_ID_DAMAGE_CB,
|
||||
GUI_ID_CREATIVE_CB,
|
||||
GUI_ID_JOIN_GAME_BUTTON,
|
||||
|
|
@ -63,6 +64,7 @@ struct MainMenuData
|
|||
// Client opts
|
||||
fancy_trees(false),
|
||||
smooth_lighting(false),
|
||||
particles(true),
|
||||
// Server opts
|
||||
creative_mode(false),
|
||||
enable_damage(false),
|
||||
|
|
@ -88,7 +90,7 @@ struct MainMenuData
|
|||
//bool bilinear_filter;
|
||||
//bool trilinear_filter;
|
||||
//int enable_shaders;
|
||||
//bool enable_particles;
|
||||
bool particles;
|
||||
// Server options
|
||||
bool creative_mode;
|
||||
bool enable_damage;
|
||||
|
|
|
|||
12
src/light.h
12
src/light.h
|
|
@ -86,5 +86,17 @@ inline u8 decode_light(u8 light)
|
|||
return light_decode_table[light];
|
||||
}
|
||||
|
||||
// 0 <= daylight_factor <= 1000
|
||||
// 0 <= lightday, lightnight <= LIGHT_SUN
|
||||
// 0 <= return value <= LIGHT_SUN
|
||||
inline u8 blend_light(u32 daylight_factor, u8 lightday, u8 lightnight)
|
||||
{
|
||||
u32 c = 1000;
|
||||
u32 l = ((daylight_factor * lightday + (c-daylight_factor) * lightnight))/c;
|
||||
if(l > LIGHT_SUN)
|
||||
l = LIGHT_SUN;
|
||||
return l;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1559,6 +1559,7 @@ int main(int argc, char *argv[])
|
|||
menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
|
||||
menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
|
||||
menudata.opaque_water = g_settings->getBool("opaque_water");
|
||||
menudata.particles = g_settings->getBool("enable_particles");
|
||||
menudata.creative_mode = g_settings->getBool("creative_mode");
|
||||
menudata.enable_damage = g_settings->getBool("enable_damage");
|
||||
|
||||
|
|
@ -1633,6 +1634,7 @@ int main(int argc, char *argv[])
|
|||
g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
|
||||
g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
|
||||
g_settings->set("opaque_water", itos(menudata.opaque_water));
|
||||
g_settings->set("enable_particles", itos(menudata.particles));
|
||||
g_settings->set("creative_mode", itos(menudata.creative_mode));
|
||||
g_settings->set("enable_damage", itos(menudata.enable_damage));
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,410 @@
|
|||
/*
|
||||
Minetest-c55
|
||||
Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published by
|
||||
the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#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 "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)
|
||||
{
|
||||
|
||||
// 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);
|
||||
video::SColor c(255, m_light, m_light, m_light);
|
||||
|
||||
video::S3DVertex vertices[4] =
|
||||
{
|
||||
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()),
|
||||
};
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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.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);
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
if (all_particlespawners.find(id) != all_particlespawners.end())
|
||||
{
|
||||
delete all_particlespawners.find(id)->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);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,150 @@
|
|||
/*
|
||||
Minetest-c55
|
||||
Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published by
|
||||
the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#ifndef PARTICLES_HEADER
|
||||
#define PARTICLES_HEADER
|
||||
|
||||
#define DIGGING_PARTICLES_AMOUNT 64
|
||||
|
||||
#include <iostream>
|
||||
#include "common_irrlicht.h"
|
||||
#include "tile.h"
|
||||
#include "player.h"
|
||||
#include "environment.h"
|
||||
|
||||
class Particle : public scene::ISceneNode
|
||||
{
|
||||
public:
|
||||
Particle(
|
||||
scene::ISceneManager* mgr,
|
||||
LocalPlayer *player,
|
||||
s32 id,
|
||||
v3f pos,
|
||||
v3f velocity,
|
||||
v3f acceleration,
|
||||
float expirationtime,
|
||||
float size,
|
||||
AtlasPointer *texture
|
||||
);
|
||||
~Particle();
|
||||
|
||||
virtual const core::aabbox3d<f32>& getBoundingBox() const
|
||||
{
|
||||
return m_box;
|
||||
}
|
||||
|
||||
virtual u32 getMaterialCount() const
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
virtual video::SMaterial& getMaterial(u32 i)
|
||||
{
|
||||
return m_material;
|
||||
}
|
||||
|
||||
virtual void OnRegisterSceneNode();
|
||||
virtual void render();
|
||||
|
||||
void step(float dtime, ClientEnvironment &env);
|
||||
|
||||
bool get_expired ()
|
||||
{ return m_expiration < m_time; }
|
||||
|
||||
private:
|
||||
float m_time;
|
||||
float m_expiration;
|
||||
|
||||
core::aabbox3d<f32> m_box;
|
||||
core::aabbox3d<f32> m_collisionbox;
|
||||
video::SMaterial m_material;
|
||||
v3f m_pos;
|
||||
v3f m_velocity;
|
||||
v3f m_acceleration;
|
||||
float tex_x0;
|
||||
float tex_x1;
|
||||
float tex_y0;
|
||||
float tex_y1;
|
||||
LocalPlayer *m_player;
|
||||
float m_size;
|
||||
AtlasPointer *m_ap;
|
||||
u8 m_light;
|
||||
};
|
||||
|
||||
class ParticleSpawner
|
||||
{
|
||||
public:
|
||||
ParticleSpawner(
|
||||
scene::ISceneManager *smgr,
|
||||
LocalPlayer *player,
|
||||
u16 amount,
|
||||
float time,
|
||||
v3f minp, v3f maxp,
|
||||
v3f minvel, v3f maxvel,
|
||||
v3f minacc, v3f maxacc,
|
||||
float minexptime, float maxexptime,
|
||||
float minsize, float maxsize,
|
||||
bool collisiondetection,
|
||||
AtlasPointer *texture,
|
||||
u32 id
|
||||
);
|
||||
|
||||
~ParticleSpawner();
|
||||
|
||||
void step(float dtime, ClientEnvironment &env);
|
||||
|
||||
bool get_expired () { return (m_amount <= 0) && m_spawntime != 0; }
|
||||
|
||||
private:
|
||||
float m_time;
|
||||
scene::ISceneManager *m_smgr;
|
||||
LocalPlayer *m_player;
|
||||
u16 m_amount;
|
||||
float m_spawntime;
|
||||
v3f m_minpos;
|
||||
v3f m_maxpos;
|
||||
v3f m_minvel;
|
||||
v3f m_maxvel;
|
||||
v3f m_minacc;
|
||||
v3f m_maxacc;
|
||||
float m_minexptime;
|
||||
float m_maxexptime;
|
||||
float m_minsize;
|
||||
float m_maxsize;
|
||||
AtlasPointer *m_ap;
|
||||
std::vector<float> m_spawntimes;
|
||||
bool m_collisiondetection;
|
||||
};
|
||||
|
||||
void allparticles_step (float dtime, ClientEnvironment &env);
|
||||
void allparticlespawners_step (float dtime, ClientEnvironment &env);
|
||||
void delete_particlespawner(u32 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);
|
||||
void clear_particles();
|
||||
|
||||
void addDiggingParticles(scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[]);
|
||||
void addPunchingParticles(scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[]);
|
||||
void addNodeParticle(scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[]);
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue