*/
#include "particles.h"
-#include "constants.h"
-#include "debug.h"
-#include "settings.h"
-#include "client/tile.h"
-#include "gamedef.h"
+#include "client.h"
#include "collision.h"
#include <stdlib.h>
#include "util/numeric.h"
rand()/(float)RAND_MAX*(max.Z-min.Z)+min.Z);
}
-u32 check_material_type_param(u32 material_type_param)
-{
- u32 alphaSource = (material_type_param & 0x0000F000) >> 12;
- u32 modulo = (material_type_param & 0x00000F00) >> 8;
- u32 srcFact = (material_type_param & 0x000000F0) >> 4;
- u32 dstFact = material_type_param & 0x0000000F;
- if (alphaSource <= 3 && modulo <= 4 && srcFact <= 10 && dstFact <= 10) {
- return material_type_param;
- } else {
- errorstream << "Server send incorrect ";
- errorstream << "material_type_param value for particle.";
- errorstream << std::endl;
- return 0;
- }
-}
-
Particle::Particle(
IGameDef *gamedef,
scene::ISceneManager* smgr,
video::ITexture *texture,
v2f texpos,
v2f texsize,
- u32 material_type_param,
- u16 vertical_frame_num,
- u16 horizontal_frame_num,
- u16 first_frame,
- float frame_length,
- bool loop_animation,
- u8 glow
+ const struct TileAnimationParams &anim,
+ u8 glow,
+ video::SColor color
):
scene::ISceneNode(smgr->getRootSceneNode(), smgr)
{
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);
- if (material_type_param != 0) {
- m_material.MaterialType = video::EMT_ONETEXTURE_BLEND;
- m_material.MaterialTypeParam = irr::core::FR(material_type_param);
- // We must disable z-buffer if we want to avoid transparent pixels
- // to overlap pixels with lower z-value.
- m_material.setFlag(video::EMF_ZWRITE_ENABLE, false);
- } else {
- m_material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- }
+ m_material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
m_material.setTexture(0, texture);
-
m_texpos = texpos;
m_texsize = texsize;
- m_vertical_frame_num = vertical_frame_num;
- m_horizontal_frame_num = horizontal_frame_num;
- m_first_frame = first_frame;
- m_frame_length = frame_length;
- m_loop_animation = loop_animation;
- m_texsize.Y /= m_vertical_frame_num;
- m_texsize.X /= m_horizontal_frame_num;
+ m_animation = anim;
+ m_animation_frame = 0;
+ m_animation_time = 0.0;
+
+ // Color
+ m_base_color = color;
+ m_color = color;
// Particle related
m_pos = pos;
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();
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);
- u16 frame = m_first_frame;
- if (m_frame_length > 0) {
- if (m_loop_animation)
- frame = m_first_frame + (u32)(m_time / m_frame_length)
- % (m_vertical_frame_num *
- m_horizontal_frame_num - m_first_frame);
- else if (m_time >=
- (m_vertical_frame_num * m_horizontal_frame_num
- - m_first_frame) * m_frame_length)
- frame = m_vertical_frame_num * m_horizontal_frame_num - 1;
- else
- frame = m_first_frame + (u16)(m_time / m_frame_length);
+ 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;
}
- f32 tx0 = m_texpos.X + m_texsize.X * (frame % m_horizontal_frame_num);
- f32 tx1 = m_texpos.X + m_texsize.X * (frame % m_horizontal_frame_num + 1);
- f32 ty0 = m_texpos.Y + m_texsize.Y * (frame / m_horizontal_frame_num);
- f32 ty1 = m_texpos.Y + m_texsize.Y * (frame / m_horizontal_frame_num + 1);
-
- 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++)
v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
float minexptime, float maxexptime, float minsize, float maxsize,
bool collisiondetection, bool collision_removal, u16 attached_id, bool vertical,
- video::ITexture *texture, u32 id,
- u32 material_type_param,
- u16 vertical_frame_num,
- u16 horizontal_frame_num,
- u16 min_first_frame,
- u16 max_first_frame,
- float frame_length,
- bool loop_animation,
+ video::ITexture *texture, u32 id, const struct TileAnimationParams &anim,
u8 glow,
ParticleManager *p_manager) :
m_particlemanager(p_manager)
m_vertical = vertical;
m_texture = texture;
m_time = 0;
- m_vertical_frame_num = vertical_frame_num;
- m_horizontal_frame_num = horizontal_frame_num;
- m_min_first_frame = min_first_frame;
- m_max_first_frame = max_first_frame;
- m_frame_length = frame_length;
- m_loop_animation = loop_animation;
- m_material_type_param = material_type_param;
+ m_animation = anim;
m_glow = glow;
for (u16 i = 0; i<=m_amount; i++)
void ParticleSpawner::step(float dtime, ClientEnvironment* env)
{
m_time += dtime;
+
bool unloaded = false;
- v3f attached_offset = v3f(0,0,0);
+ 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_offset = attached->getPosition() / BS;
- else
+ 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
v3f pos = random_v3f(m_minpos, m_maxpos);
v3f vel = random_v3f(m_minvel, m_maxvel);
v3f acc = random_v3f(m_minacc, m_maxacc);
- // Make relative to offest
- pos += attached_offset;
+
+ 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;
- u16 first_frame = m_min_first_frame +
- rand() %
- (m_max_first_frame -
- m_min_first_frame + 1);
+
Particle* toadd = new Particle(
m_gamedef,
m_smgr,
m_texture,
v2f(0.0, 0.0),
v2f(1.0, 1.0),
- m_material_type_param,
- m_vertical_frame_num,
- m_horizontal_frame_num,
- first_frame,
- m_frame_length,
- m_loop_animation,
+ m_animation,
m_glow);
m_particlemanager->addParticle(toadd);
}
{
if (rand()/(float)RAND_MAX < dtime)
{
- v3f pos = random_v3f(m_minpos, m_maxpos)
- + attached_offset;
+ 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;
- u16 first_frame = m_min_first_frame +
- rand() %
- (m_max_first_frame -
- m_min_first_frame + 1);
+
Particle* toadd = new Particle(
m_gamedef,
m_smgr,
m_texture,
v2f(0.0, 0.0),
v2f(1.0, 1.0),
- m_material_type_param,
- m_vertical_frame_num,
- m_horizontal_frame_num,
- first_frame,
- m_frame_length,
- m_loop_animation,
+ m_animation,
m_glow);
m_particlemanager->addParticle(toadd);
}
}
}
-void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
+void ParticleManager::handleParticleEvent(ClientEvent *event, Client *client,
scene::ISceneManager* smgr, LocalPlayer *player)
{
switch (event->type) {
}
video::ITexture *texture =
- gamedef->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
-
- float frame_length = -1;
- u16 vertical_frame_num = 1;
- u16 horizontal_frame_num = 1;
- u32 material_type_param =
- check_material_type_param(event->add_particlespawner.material_type_param);
-
- switch (event->add_particlespawner.animation_type) {
- case AT_NONE:
- break;
- case AT_VERTICAL_FRAMES: {
- v2u32 size = texture->getOriginalSize();
- int frame_height = (float)size.X /
- (float)event->add_particlespawner.vertical_frame_num *
- (float)event->add_particlespawner.horizontal_frame_num;
- vertical_frame_num = size.Y / frame_height;
- frame_length =
- event->add_particlespawner.frame_length /
- vertical_frame_num;
- break;
- }
- case AT_2D_ANIMATION_SHEET: {
- vertical_frame_num =
- event->add_particlespawner.vertical_frame_num;
- horizontal_frame_num =
- event->add_particlespawner.horizontal_frame_num;
- frame_length =
- event->add_particlespawner.frame_length;
- break;
- }
- default:
- break;
- }
+ client->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
- ParticleSpawner* toadd = new ParticleSpawner(gamedef, smgr, player,
+ ParticleSpawner* toadd = new ParticleSpawner(client, smgr, player,
event->add_particlespawner.amount,
event->add_particlespawner.spawntime,
*event->add_particlespawner.minpos,
event->add_particlespawner.vertical,
texture,
event->add_particlespawner.id,
- material_type_param,
- vertical_frame_num,
- horizontal_frame_num,
- event->add_particlespawner.min_first_frame,
- event->add_particlespawner.max_first_frame,
- frame_length,
- event->add_particlespawner.loop_animation,
+ event->add_particlespawner.animation,
event->add_particlespawner.glow,
this);
}
case CE_SPAWN_PARTICLE: {
video::ITexture *texture =
- gamedef->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
-
- float frame_length = -1;
- u16 vertical_frame_num = 1;
- u16 horizontal_frame_num = 1;
- u32 material_type_param =
- check_material_type_param(event->spawn_particle.material_type_param);
-
- switch (event->spawn_particle.animation_type) {
- case AT_NONE:
- break;
- case AT_VERTICAL_FRAMES: {
- v2u32 size = texture->getOriginalSize();
- int frame_height = (float)size.X /
- (float)event->spawn_particle.vertical_frame_num *
- (float)event->spawn_particle.horizontal_frame_num;
- vertical_frame_num = size.Y / frame_height;
- frame_length =
- event->spawn_particle.frame_length /
- vertical_frame_num;
- break;
- }
- case AT_2D_ANIMATION_SHEET: {
- vertical_frame_num =
- event->spawn_particle.vertical_frame_num;
- horizontal_frame_num =
- event->spawn_particle.horizontal_frame_num;
- frame_length =
- event->spawn_particle.frame_length;
- break;
- }
- default:
- break;
- }
+ client->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
- Particle* toadd = new Particle(gamedef, smgr, player, m_env,
+ Particle* toadd = new Particle(client, smgr, player, m_env,
*event->spawn_particle.pos,
*event->spawn_particle.vel,
*event->spawn_particle.acc,
texture,
v2f(0.0, 0.0),
v2f(1.0, 1.0),
- material_type_param,
- vertical_frame_num,
- horizontal_frame_num,
- event->spawn_particle.first_frame,
- frame_length,
- event->spawn_particle.loop_animation,
+ event->spawn_particle.animation,
event->spawn_particle.glow);
addParticle(toadd);
}
}
-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);
- video::ITexture *texture = tiles[texid].texture;
+ 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
- f32 ymax = 1;
- if(tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
- ymax /= tiles[texid].animation_frame_count;
+ 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;
- v2f texsize(size * 2, ymax * size * 2);
+ v2f texsize(size * 2, size * 2);
v2f texpos;
texpos.X = ((rand() % 64) / 64. - texsize.X);
- texpos.Y = ymax * ((rand() % 64) / 64. - texsize.Y);
+ texpos.Y = ((rand() % 64) / 64. - texsize.Y);
// Physics
v3f velocity((rand() % 100 / 50. - 1) / 1.5,
(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,
texture,
texpos,
texsize,
- 0, 1, 1, 0, -1, true, 0);
+ anim,
+ 0,
+ color);
addParticle(toadd);
}
projects / oweals / minetest.git / blobdiff