src/client/particles.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "particles.h"
  21 #include <cmath>
  22 #include "client.h"
  23 #include "collision.h"
  24 #include "client/content_cao.h"
  25 #include "client/clientevent.h"
  26 #include "client/renderingengine.h"
  27 #include "util/numeric.h"
  28 #include "light.h"
  29 #include "environment.h"
  30 #include "clientmap.h"
  31 #include "mapnode.h"
  32 #include "nodedef.h"
  33 #include "client.h"
  34 #include "settings.h"
  35
  36 /*
  37         Utility
  38 */
  39
  40 static f32 random_f32(f32 min, f32 max)
  41 {
  42         return rand() / (float)RAND_MAX * (max - min) + min;
  43 }
  44
  45 static v3f random_v3f(v3f min, v3f max)
  46 {
  47         return v3f(
  48                 random_f32(min.X, max.X),
  49                 random_f32(min.Y, max.Y),
  50                 random_f32(min.Z, max.Z));
  51 }
  52
  53 /*
  54         Particle
  55 */
  56
  57 Particle::Particle(
  58         IGameDef *gamedef,
  59         LocalPlayer *player,
  60         ClientEnvironment *env,
  61         const ParticleParameters &p,
  62         video::ITexture *texture,
  63         v2f texpos,
  64         v2f texsize,
  65         video::SColor color
  66 ):
  67         scene::ISceneNode(((Client *)gamedef)->getSceneManager()->getRootSceneNode(),
  68                 ((Client *)gamedef)->getSceneManager())
  69 {
  70         // Misc
  71         m_gamedef = gamedef;
  72         m_env = env;
  73
  74         // Texture
  75         m_material.setFlag(video::EMF_LIGHTING, false);
  76         m_material.setFlag(video::EMF_BACK_FACE_CULLING, false);
  77         m_material.setFlag(video::EMF_BILINEAR_FILTER, false);
  78         m_material.setFlag(video::EMF_FOG_ENABLE, true);
  79         m_material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
  80         m_material.setTexture(0, texture);
  81         m_texpos = texpos;
  82         m_texsize = texsize;
  83         m_animation = p.animation;
  84
  85         // Color
  86         m_base_color = color;
  87         m_color = color;
  88
  89         // Particle related
  90         m_pos = p.pos;
  91         m_velocity = p.vel;
  92         m_acceleration = p.acc;
  93         m_expiration = p.expirationtime;
  94         m_player = player;
  95         m_size = p.size;
  96         m_collisiondetection = p.collisiondetection;
  97         m_collision_removal = p.collision_removal;
  98         m_object_collision = p.object_collision;
  99         m_vertical = p.vertical;
 100         m_glow = p.glow;
 101
 102         // Irrlicht stuff
 103         const float c = p.size / 2;
 104         m_collisionbox = aabb3f(-c, -c, -c, c, c, c);
 105         this->setAutomaticCulling(scene::EAC_OFF);
 106
 107         // Init lighting
 108         updateLight();
 109
 110         // Init model
 111         updateVertices();
 112 }
 113
 114 void Particle::OnRegisterSceneNode()
 115 {
 116         if (IsVisible)
 117                 SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT_EFFECT);
 118
 119         ISceneNode::OnRegisterSceneNode();
 120 }
 121
 122 void Particle::render()
 123 {
 124         video::IVideoDriver *driver = SceneManager->getVideoDriver();
 125         driver->setMaterial(m_material);
 126         driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
 127
 128         u16 indices[] = {0,1,2, 2,3,0};
 129         driver->drawVertexPrimitiveList(m_vertices, 4,
 130                         indices, 2, video::EVT_STANDARD,
 131                         scene::EPT_TRIANGLES, video::EIT_16BIT);
 132 }
 133
 134 void Particle::step(float dtime)
 135 {
 136         m_time += dtime;
 137         if (m_collisiondetection) {
 138                 aabb3f box = m_collisionbox;
 139                 v3f p_pos = m_pos * BS;
 140                 v3f p_velocity = m_velocity * BS;
 141                 collisionMoveResult r = collisionMoveSimple(m_env, m_gamedef, BS * 0.5f,
 142                         box, 0.0f, dtime, &p_pos, &p_velocity, m_acceleration * BS, nullptr,
 143                         m_object_collision);
 144                 if (m_collision_removal && r.collides) {
 145                         // force expiration of the particle
 146                         m_expiration = -1.0;
 147                 } else {
 148                         m_pos = p_pos / BS;
 149                         m_velocity = p_velocity / BS;
 150                 }
 151         } else {
 152                 m_velocity += m_acceleration * dtime;
 153                 m_pos += m_velocity * dtime;
 154         }
 155         if (m_animation.type != TAT_NONE) {
 156                 m_animation_time += dtime;
 157                 int frame_length_i, frame_count;
 158                 m_animation.determineParams(
 159                                 m_material.getTexture(0)->getSize(),
 160                                 &frame_count, &frame_length_i, NULL);
 161                 float frame_length = frame_length_i / 1000.0;
 162                 while (m_animation_time > frame_length) {
 163                         m_animation_frame++;
 164                         m_animation_time -= frame_length;
 165                 }
 166         }
 167
 168         // Update lighting
 169         updateLight();
 170
 171         // Update model
 172         updateVertices();
 173 }
 174
 175 void Particle::updateLight()
 176 {
 177         u8 light = 0;
 178         bool pos_ok;
 179
 180         v3s16 p = v3s16(
 181                 floor(m_pos.X+0.5),
 182                 floor(m_pos.Y+0.5),
 183                 floor(m_pos.Z+0.5)
 184         );
 185         MapNode n = m_env->getClientMap().getNode(p, &pos_ok);
 186         if (pos_ok)
 187                 light = n.getLightBlend(m_env->getDayNightRatio(), m_gamedef->ndef());
 188         else
 189                 light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
 190
 191         u8 m_light = decode_light(light + m_glow);
 192         m_color.set(255,
 193                 m_light * m_base_color.getRed() / 255,
 194                 m_light * m_base_color.getGreen() / 255,
 195                 m_light * m_base_color.getBlue() / 255);
 196 }
 197
 198 void Particle::updateVertices()
 199 {
 200         f32 tx0, tx1, ty0, ty1;
 201
 202         if (m_animation.type != TAT_NONE) {
 203                 const v2u32 texsize = m_material.getTexture(0)->getSize();
 204                 v2f texcoord, framesize_f;
 205                 v2u32 framesize;
 206                 texcoord = m_animation.getTextureCoords(texsize, m_animation_frame);
 207                 m_animation.determineParams(texsize, NULL, NULL, &framesize);
 208                 framesize_f = v2f(framesize.X / (float) texsize.X, framesize.Y / (float) texsize.Y);
 209
 210                 tx0 = m_texpos.X + texcoord.X;
 211                 tx1 = m_texpos.X + texcoord.X + framesize_f.X * m_texsize.X;
 212                 ty0 = m_texpos.Y + texcoord.Y;
 213                 ty1 = m_texpos.Y + texcoord.Y + framesize_f.Y * m_texsize.Y;
 214         } else {
 215                 tx0 = m_texpos.X;
 216                 tx1 = m_texpos.X + m_texsize.X;
 217                 ty0 = m_texpos.Y;
 218                 ty1 = m_texpos.Y + m_texsize.Y;
 219         }
 220
 221         m_vertices[0] = video::S3DVertex(-m_size / 2, -m_size / 2,
 222                 0, 0, 0, 0, m_color, tx0, ty1);
 223         m_vertices[1] = video::S3DVertex(m_size / 2, -m_size / 2,
 224                 0, 0, 0, 0, m_color, tx1, ty1);
 225         m_vertices[2] = video::S3DVertex(m_size / 2, m_size / 2,
 226                 0, 0, 0, 0, m_color, tx1, ty0);
 227         m_vertices[3] = video::S3DVertex(-m_size / 2, m_size / 2,
 228                 0, 0, 0, 0, m_color, tx0, ty0);
 229
 230         v3s16 camera_offset = m_env->getCameraOffset();
 231         for (video::S3DVertex &vertex : m_vertices) {
 232                 if (m_vertical) {
 233                         v3f ppos = m_player->getPosition()/BS;
 234                         vertex.Pos.rotateXZBy(std::atan2(ppos.Z - m_pos.Z, ppos.X - m_pos.X) /
 235                                 core::DEGTORAD + 90);
 236                 } else {
 237                         vertex.Pos.rotateYZBy(m_player->getPitch());
 238                         vertex.Pos.rotateXZBy(m_player->getYaw());
 239                 }
 240                 m_box.addInternalPoint(vertex.Pos);
 241                 vertex.Pos += m_pos*BS - intToFloat(camera_offset, BS);
 242         }
 243 }
 244
 245 /*
 246         ParticleSpawner
 247 */
 248
 249 ParticleSpawner::ParticleSpawner(
 250         IGameDef *gamedef,
 251         LocalPlayer *player,
 252         const ParticleSpawnerParameters &p,
 253         u16 attached_id,
 254         video::ITexture *texture,
 255         ParticleManager *p_manager
 256 ):
 257         m_particlemanager(p_manager), p(p)
 258 {
 259         m_gamedef = gamedef;
 260         m_player = player;
 261         m_attached_id = attached_id;
 262         m_texture = texture;
 263         m_time = 0;
 264
 265         m_spawntimes.reserve(p.amount + 1);
 266         for (u16 i = 0; i <= p.amount; i++) {
 267                 float spawntime = rand() / (float)RAND_MAX * p.time;
 268                 m_spawntimes.push_back(spawntime);
 269         }
 270 }
 271
 272 void ParticleSpawner::spawnParticle(ClientEnvironment *env, float radius,
 273         const core::matrix4 *attached_absolute_pos_rot_matrix)
 274 {
 275         v3f ppos = m_player->getPosition() / BS;
 276         v3f pos = random_v3f(p.minpos, p.maxpos);
 277
 278         // Need to apply this first or the following check
 279         // will be wrong for attached spawners
 280         if (attached_absolute_pos_rot_matrix) {
 281                 pos *= BS;
 282                 attached_absolute_pos_rot_matrix->transformVect(pos);
 283                 pos /= BS;
 284                 v3s16 camera_offset = m_particlemanager->m_env->getCameraOffset();
 285                 pos.X += camera_offset.X;
 286                 pos.Y += camera_offset.Y;
 287                 pos.Z += camera_offset.Z;
 288         }
 289
 290         if (pos.getDistanceFrom(ppos) > radius)
 291                 return;
 292
 293         // Parameters for the single particle we're about to spawn
 294         ParticleParameters pp;
 295         pp.pos = pos;
 296
 297         pp.vel = random_v3f(p.minvel, p.maxvel);
 298         pp.acc = random_v3f(p.minacc, p.maxacc);
 299
 300         if (attached_absolute_pos_rot_matrix) {
 301                 // Apply attachment rotation
 302                 attached_absolute_pos_rot_matrix->rotateVect(pp.vel);
 303                 attached_absolute_pos_rot_matrix->rotateVect(pp.acc);
 304         }
 305
 306         pp.expirationtime = random_f32(p.minexptime, p.maxexptime);
 307         p.copyCommon(pp);
 308
 309         video::ITexture *texture;
 310         v2f texpos, texsize;
 311         video::SColor color(0xFFFFFFFF);
 312
 313         if (p.node.getContent() != CONTENT_IGNORE) {
 314                 const ContentFeatures &f =
 315                         m_particlemanager->m_env->getGameDef()->ndef()->get(p.node);
 316                 if (!ParticleManager::getNodeParticleParams(p.node, f, pp, &texture,
 317                                 texpos, texsize, &color, p.node_tile))
 318                         return;
 319         } else {
 320                 texture = m_texture;
 321                 texpos = v2f(0.0f, 0.0f);
 322                 texsize = v2f(1.0f, 1.0f);
 323         }
 324
 325         // Allow keeping default random size
 326         if (p.maxsize > 0.0f)
 327                 pp.size = random_f32(p.minsize, p.maxsize);
 328
 329         m_particlemanager->addParticle(new Particle(
 330                 m_gamedef,
 331                 m_player,
 332                 env,
 333                 pp,
 334                 texture,
 335                 texpos,
 336                 texsize,
 337                 color
 338         ));
 339 }
 340
 341 void ParticleSpawner::step(float dtime, ClientEnvironment *env)
 342 {
 343         m_time += dtime;
 344
 345         static thread_local const float radius =
 346                         g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE;
 347
 348         bool unloaded = false;
 349         const core::matrix4 *attached_absolute_pos_rot_matrix = nullptr;
 350         if (m_attached_id) {
 351                 if (GenericCAO *attached = dynamic_cast<GenericCAO *>(env->getActiveObject(m_attached_id))) {
 352                         attached_absolute_pos_rot_matrix = attached->getAbsolutePosRotMatrix();
 353                 } else {
 354                         unloaded = true;
 355                 }
 356         }
 357
 358         if (p.time != 0) {
 359                 // Spawner exists for a predefined timespan
 360                 for (auto i = m_spawntimes.begin(); i != m_spawntimes.end(); ) {
 361                         if ((*i) <= m_time && p.amount > 0) {
 362                                 --p.amount;
 363
 364                                 // Pretend to, but don't actually spawn a particle if it is
 365                                 // attached to an unloaded object or distant from player.
 366                                 if (!unloaded)
 367                                         spawnParticle(env, radius, attached_absolute_pos_rot_matrix);
 368
 369                                 i = m_spawntimes.erase(i);
 370                         } else {
 371                                 ++i;
 372                         }
 373                 }
 374         } else {
 375                 // Spawner exists for an infinity timespan, spawn on a per-second base
 376
 377                 // Skip this step if attached to an unloaded object
 378                 if (unloaded)
 379                         return;
 380
 381                 for (int i = 0; i <= p.amount; i++) {
 382                         if (rand() / (float)RAND_MAX < dtime)
 383                                 spawnParticle(env, radius, attached_absolute_pos_rot_matrix);
 384                 }
 385         }
 386 }
 387
 388 /*
 389         ParticleManager
 390 */
 391
 392 ParticleManager::ParticleManager(ClientEnvironment *env) :
 393         m_env(env)
 394 {}
 395
 396 ParticleManager::~ParticleManager()
 397 {
 398         clearAll();
 399 }
 400
 401 void ParticleManager::step(float dtime)
 402 {
 403         stepParticles (dtime);
 404         stepSpawners (dtime);
 405 }
 406
 407 void ParticleManager::stepSpawners(float dtime)
 408 {
 409         MutexAutoLock lock(m_spawner_list_lock);
 410         for (auto i = m_particle_spawners.begin(); i != m_particle_spawners.end();) {
 411                 if (i->second->get_expired()) {
 412                         delete i->second;
 413                         m_particle_spawners.erase(i++);
 414                 } else {
 415                         i->second->step(dtime, m_env);
 416                         ++i;
 417                 }
 418         }
 419 }
 420
 421 void ParticleManager::stepParticles(float dtime)
 422 {
 423         MutexAutoLock lock(m_particle_list_lock);
 424         for (auto i = m_particles.begin(); i != m_particles.end();) {
 425                 if ((*i)->get_expired()) {
 426                         (*i)->remove();
 427                         delete *i;
 428                         i = m_particles.erase(i);
 429                 } else {
 430                         (*i)->step(dtime);
 431                         ++i;
 432                 }
 433         }
 434 }
 435
 436 void ParticleManager::clearAll()
 437 {
 438         MutexAutoLock lock(m_spawner_list_lock);
 439         MutexAutoLock lock2(m_particle_list_lock);
 440         for (auto i = m_particle_spawners.begin(); i != m_particle_spawners.end();) {
 441                 delete i->second;
 442                 m_particle_spawners.erase(i++);
 443         }
 444
 445         for(auto i = m_particles.begin(); i != m_particles.end();)
 446         {
 447                 (*i)->remove();
 448                 delete *i;
 449                 i = m_particles.erase(i);
 450         }
 451 }
 452
 453 void ParticleManager::handleParticleEvent(ClientEvent *event, Client *client,
 454         LocalPlayer *player)
 455 {
 456         switch (event->type) {
 457                 case CE_DELETE_PARTICLESPAWNER: {
 458                         deleteParticleSpawner(event->delete_particlespawner.id);
 459                         // no allocated memory in delete event
 460                         break;
 461                 }
 462                 case CE_ADD_PARTICLESPAWNER: {
 463                         deleteParticleSpawner(event->add_particlespawner.id);
 464
 465                         const ParticleSpawnerParameters &p = *event->add_particlespawner.p;
 466
 467                         video::ITexture *texture =
 468                                 client->tsrc()->getTextureForMesh(p.texture);
 469
 470                         auto toadd = new ParticleSpawner(client, player,
 471                                         p,
 472                                         event->add_particlespawner.attached_id,
 473                                         texture,
 474                                         this);
 475
 476                         addParticleSpawner(event->add_particlespawner.id, toadd);
 477
 478                         delete event->add_particlespawner.p;
 479                         break;
 480                 }
 481                 case CE_SPAWN_PARTICLE: {
 482                         ParticleParameters &p = *event->spawn_particle;
 483
 484                         video::ITexture *texture;
 485                         v2f texpos, texsize;
 486                         video::SColor color(0xFFFFFFFF);
 487
 488                         f32 oldsize = p.size;
 489
 490                         if (p.node.getContent() != CONTENT_IGNORE) {
 491                                 const ContentFeatures &f = m_env->getGameDef()->ndef()->get(p.node);
 492                                 if (!getNodeParticleParams(p.node, f, p, &texture, texpos,
 493                                                 texsize, &color, p.node_tile))
 494                                         texture = nullptr;
 495                         } else {
 496                                 texture = client->tsrc()->getTextureForMesh(p.texture);
 497                                 texpos = v2f(0.0f, 0.0f);
 498                                 texsize = v2f(1.0f, 1.0f);
 499                         }
 500
 501                         // Allow keeping default random size
 502                         if (oldsize > 0.0f)
 503                                 p.size = oldsize;
 504
 505                         if (texture) {
 506                                 Particle *toadd = new Particle(client, player, m_env,
 507                                                 p, texture, texpos, texsize, color);
 508
 509                                 addParticle(toadd);
 510                         }
 511
 512                         delete event->spawn_particle;
 513                         break;
 514                 }
 515                 default: break;
 516         }
 517 }
 518
 519 bool ParticleManager::getNodeParticleParams(const MapNode &n,
 520         const ContentFeatures &f, ParticleParameters &p, video::ITexture **texture,
 521         v2f &texpos, v2f &texsize, video::SColor *color, u8 tilenum)
 522 {
 523         // No particles for "airlike" nodes
 524         if (f.drawtype == NDT_AIRLIKE)
 525                 return false;
 526
 527         // Texture
 528         u8 texid;
 529         if (tilenum > 0 && tilenum <= 6)
 530                 texid = tilenum - 1;
 531         else
 532                 texid = rand() % 6;
 533         const TileLayer &tile = f.tiles[texid].layers[0];
 534         p.animation.type = TAT_NONE;
 535
 536         // Only use first frame of animated texture
 537         if (tile.material_flags & MATERIAL_FLAG_ANIMATION)
 538                 *texture = (*tile.frames)[0].texture;
 539         else
 540                 *texture = tile.texture;
 541
 542         float size = (rand() % 8) / 64.0f;
 543         p.size = BS * size;
 544         if (tile.scale)
 545                 size /= tile.scale;
 546         texsize = v2f(size * 2.0f, size * 2.0f);
 547         texpos.X = (rand() % 64) / 64.0f - texsize.X;
 548         texpos.Y = (rand() % 64) / 64.0f - texsize.Y;
 549
 550         if (tile.has_color)
 551                 *color = tile.color;
 552         else
 553                 n.getColor(f, color);
 554
 555         return true;
 556 }
 557
 558 // The final burst of particles when a node is finally dug, *not* particles
 559 // spawned during the digging of a node.
 560
 561 void ParticleManager::addDiggingParticles(IGameDef *gamedef,
 562         LocalPlayer *player, v3s16 pos, const MapNode &n, const ContentFeatures &f)
 563 {
 564         // No particles for "airlike" nodes
 565         if (f.drawtype == NDT_AIRLIKE)
 566                 return;
 567
 568         for (u16 j = 0; j < 16; j++) {
 569                 addNodeParticle(gamedef, player, pos, n, f);
 570         }
 571 }
 572
 573 // During the digging of a node particles are spawned individually by this
 574 // function, called from Game::handleDigging() in game.cpp.
 575
 576 void ParticleManager::addNodeParticle(IGameDef *gamedef,
 577         LocalPlayer *player, v3s16 pos, const MapNode &n, const ContentFeatures &f)
 578 {
 579         ParticleParameters p;
 580         video::ITexture *texture;
 581         v2f texpos, texsize;
 582         video::SColor color;
 583
 584         if (!getNodeParticleParams(n, f, p, &texture, texpos, texsize, &color))
 585                 return;
 586
 587         p.expirationtime = (rand() % 100) / 100.0f;
 588
 589         // Physics
 590         p.vel = v3f(
 591                 (rand() % 150) / 50.0f - 1.5f,
 592                 (rand() % 150) / 50.0f,
 593                 (rand() % 150) / 50.0f - 1.5f
 594         );
 595         p.acc = v3f(
 596                 0.0f,
 597                 -player->movement_gravity * player->physics_override_gravity / BS,
 598                 0.0f
 599         );
 600         p.pos = v3f(
 601                 (f32)pos.X + (rand() % 100) / 200.0f - 0.25f,
 602                 (f32)pos.Y + (rand() % 100) / 200.0f - 0.25f,
 603                 (f32)pos.Z + (rand() % 100) / 200.0f - 0.25f
 604         );
 605
 606         Particle *toadd = new Particle(
 607                 gamedef,
 608                 player,
 609                 m_env,
 610                 p,
 611                 texture,
 612                 texpos,
 613                 texsize,
 614                 color);
 615
 616         addParticle(toadd);
 617 }
 618
 619 void ParticleManager::addParticle(Particle *toadd)
 620 {
 621         MutexAutoLock lock(m_particle_list_lock);
 622         m_particles.push_back(toadd);
 623 }
 624
 625
 626 void ParticleManager::addParticleSpawner(u64 id, ParticleSpawner *toadd)
 627 {
 628         MutexAutoLock lock(m_spawner_list_lock);
 629         m_particle_spawners[id] = toadd;
 630 }
 631
 632 void ParticleManager::deleteParticleSpawner(u64 id)
 633 {
 634         MutexAutoLock lock(m_spawner_list_lock);
 635         auto it = m_particle_spawners.find(id);
 636         if (it != m_particle_spawners.end()) {
 637                 delete it->second;
 638                 m_particle_spawners.erase(it);
 639         }
 640 }