2012-12-31 19:33:36 +01:00
|
|
|
/*
|
2013-02-24 18:40:43 +01:00
|
|
|
Minetest
|
2013-02-24 19:38:45 +01:00
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2012-12-31 19:33:36 +01:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2017-08-17 22:19:39 +02:00
|
|
|
#pragma once
|
2012-12-31 19:33:36 +01:00
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
#include "irrlichttypes_extrabloated.h"
|
2015-03-05 11:52:57 +01:00
|
|
|
#include "client/tile.h"
|
2012-12-31 19:33:36 +01:00
|
|
|
#include "localplayer.h"
|
2020-05-22 13:23:25 +02:00
|
|
|
#include "../particles.h"
|
2012-12-31 19:33:36 +01:00
|
|
|
|
2015-01-05 18:34:59 +01:00
|
|
|
struct ClientEvent;
|
|
|
|
class ParticleManager;
|
2016-05-28 06:08:23 +02:00
|
|
|
class ClientEnvironment;
|
2017-01-26 16:10:56 +01:00
|
|
|
struct MapNode;
|
|
|
|
struct ContentFeatures;
|
2015-01-05 18:34:59 +01:00
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
struct ClientParticleTexture
|
2022-07-13 11:57:12 +02:00
|
|
|
{
|
|
|
|
/* per-spawner structure used to store the ParticleTexture structs
|
2023-10-11 17:07:30 +02:00
|
|
|
* that spawned particles will refer to through ClientParticleTexRef */
|
2022-07-13 11:57:12 +02:00
|
|
|
ParticleTexture tex;
|
|
|
|
video::ITexture *ref = nullptr;
|
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
ClientParticleTexture() = default;
|
|
|
|
ClientParticleTexture(const ServerParticleTexture& p, ITextureSource *t):
|
2022-07-13 11:57:12 +02:00
|
|
|
tex(p),
|
|
|
|
ref(t->getTextureForMesh(p.string)) {};
|
|
|
|
};
|
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
struct ClientParticleTexRef
|
2022-07-13 11:57:12 +02:00
|
|
|
{
|
|
|
|
/* per-particle structure used to avoid massively duplicating the
|
|
|
|
* fairly large ParticleTexture struct */
|
2023-10-11 17:07:30 +02:00
|
|
|
ParticleTexture *tex = nullptr;
|
|
|
|
video::ITexture *ref = nullptr;
|
|
|
|
|
|
|
|
ClientParticleTexRef() = default;
|
2022-07-13 11:57:12 +02:00
|
|
|
|
|
|
|
/* constructor used by particles spawned from a spawner */
|
2023-10-11 17:07:30 +02:00
|
|
|
explicit ClientParticleTexRef(ClientParticleTexture &t):
|
2022-07-13 11:57:12 +02:00
|
|
|
tex(&t.tex), ref(t.ref) {};
|
|
|
|
|
|
|
|
/* constructor used for node particles */
|
2023-10-11 17:07:30 +02:00
|
|
|
explicit ClientParticleTexRef(video::ITexture *tp): ref(tp) {};
|
2022-07-13 11:57:12 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class ParticleSpawner;
|
|
|
|
|
2012-12-31 19:33:36 +01:00
|
|
|
class Particle : public scene::ISceneNode
|
|
|
|
{
|
2022-07-13 11:57:12 +02:00
|
|
|
public:
|
2012-12-31 19:33:36 +01:00
|
|
|
Particle(
|
2022-07-13 11:57:12 +02:00
|
|
|
IGameDef *gamedef,
|
2012-12-31 19:33:36 +01:00
|
|
|
LocalPlayer *player,
|
2015-01-05 18:34:59 +01:00
|
|
|
ClientEnvironment *env,
|
2020-05-22 13:23:25 +02:00
|
|
|
const ParticleParameters &p,
|
2023-10-11 17:07:30 +02:00
|
|
|
const ClientParticleTexRef &texture,
|
2013-06-24 04:17:50 +02:00
|
|
|
v2f texpos,
|
2017-01-14 16:48:49 +01:00
|
|
|
v2f texsize,
|
2023-10-11 17:07:30 +02:00
|
|
|
video::SColor color,
|
|
|
|
ParticleSpawner *parent = nullptr,
|
|
|
|
std::unique_ptr<ClientParticleTexture> owned_texture = nullptr
|
2012-12-31 19:33:36 +01:00
|
|
|
);
|
|
|
|
|
2016-02-11 15:21:21 +01:00
|
|
|
virtual const aabb3f &getBoundingBox() const
|
2012-12-31 19:33:36 +01:00
|
|
|
{
|
|
|
|
return m_box;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual u32 getMaterialCount() const
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual video::SMaterial& getMaterial(u32 i)
|
|
|
|
{
|
|
|
|
return m_material;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void OnRegisterSceneNode();
|
|
|
|
virtual void render();
|
|
|
|
|
2014-01-26 11:40:21 +01:00
|
|
|
void step(float dtime);
|
2012-12-31 19:33:36 +01:00
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
bool isExpired ()
|
2012-12-31 19:33:36 +01:00
|
|
|
{ return m_expiration < m_time; }
|
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
ParticleSpawner *getParent() { return m_parent; }
|
2022-07-13 11:57:12 +02:00
|
|
|
|
2012-12-31 19:33:36 +01:00
|
|
|
private:
|
2014-01-26 11:40:21 +01:00
|
|
|
void updateLight();
|
2013-01-23 18:32:02 +01:00
|
|
|
void updateVertices();
|
2022-07-13 11:57:12 +02:00
|
|
|
void setVertexAlpha(float a);
|
2013-01-23 18:32:02 +01:00
|
|
|
|
|
|
|
video::S3DVertex m_vertices[4];
|
2017-06-18 19:55:15 +02:00
|
|
|
float m_time = 0.0f;
|
2012-12-31 19:33:36 +01:00
|
|
|
float m_expiration;
|
|
|
|
|
2014-01-26 11:40:21 +01:00
|
|
|
ClientEnvironment *m_env;
|
2012-12-31 19:33:36 +01:00
|
|
|
IGameDef *m_gamedef;
|
2016-02-11 15:21:21 +01:00
|
|
|
aabb3f m_box;
|
|
|
|
aabb3f m_collisionbox;
|
2023-10-11 17:07:30 +02:00
|
|
|
ClientParticleTexRef m_texture;
|
2012-12-31 19:33:36 +01:00
|
|
|
video::SMaterial m_material;
|
2013-06-24 04:17:50 +02:00
|
|
|
v2f m_texpos;
|
|
|
|
v2f m_texsize;
|
2012-12-31 19:33:36 +01:00
|
|
|
v3f m_pos;
|
|
|
|
v3f m_velocity;
|
|
|
|
v3f m_acceleration;
|
2023-10-11 17:07:30 +02:00
|
|
|
const ParticleParameters m_p;
|
2012-12-31 19:33:36 +01:00
|
|
|
LocalPlayer *m_player;
|
2022-07-13 11:57:12 +02:00
|
|
|
|
2017-01-12 15:46:30 +01:00
|
|
|
//! Color without lighting
|
|
|
|
video::SColor m_base_color;
|
|
|
|
//! Final rendered color
|
|
|
|
video::SColor m_color;
|
2017-06-18 19:55:15 +02:00
|
|
|
float m_animation_time = 0.0f;
|
|
|
|
int m_animation_frame = 0;
|
2022-07-13 11:57:12 +02:00
|
|
|
float m_alpha = 0.0f;
|
2023-10-11 17:07:30 +02:00
|
|
|
|
|
|
|
ParticleSpawner *m_parent = nullptr;
|
|
|
|
// Used if not spawned from a particlespawner
|
|
|
|
std::unique_ptr<ClientParticleTexture> m_owned_texture;
|
2013-01-23 18:32:02 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class ParticleSpawner
|
|
|
|
{
|
2017-10-02 20:40:59 +02:00
|
|
|
public:
|
2022-07-13 11:57:12 +02:00
|
|
|
ParticleSpawner(IGameDef *gamedef,
|
2013-01-23 18:32:02 +01:00
|
|
|
LocalPlayer *player,
|
2023-10-11 17:07:30 +02:00
|
|
|
const ParticleSpawnerParameters ¶ms,
|
2016-08-04 22:09:21 +02:00
|
|
|
u16 attached_id,
|
2023-10-11 17:07:30 +02:00
|
|
|
std::vector<ClientParticleTexture> &&texpool,
|
|
|
|
ParticleManager *p_manager);
|
2016-11-14 15:28:06 +01:00
|
|
|
|
2015-01-05 18:34:59 +01:00
|
|
|
void step(float dtime, ClientEnvironment *env);
|
2013-01-23 18:32:02 +01:00
|
|
|
|
2022-07-13 11:57:12 +02:00
|
|
|
bool getExpired() const
|
2023-10-11 17:07:30 +02:00
|
|
|
{ return p.amount <= 0 && p.time != 0; }
|
|
|
|
|
|
|
|
bool hasActive() const { return m_active != 0; }
|
|
|
|
void decrActive() { m_active -= 1; }
|
2013-01-23 18:32:02 +01:00
|
|
|
|
2017-10-02 20:40:59 +02:00
|
|
|
private:
|
|
|
|
void spawnParticle(ClientEnvironment *env, float radius,
|
2019-08-09 10:51:17 +02:00
|
|
|
const core::matrix4 *attached_absolute_pos_rot_matrix);
|
2017-10-02 20:40:59 +02:00
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
size_t m_active;
|
2017-10-02 20:40:59 +02:00
|
|
|
ParticleManager *m_particlemanager;
|
2013-01-23 18:32:02 +01:00
|
|
|
float m_time;
|
|
|
|
IGameDef *m_gamedef;
|
|
|
|
LocalPlayer *m_player;
|
2020-05-22 13:23:25 +02:00
|
|
|
ParticleSpawnerParameters p;
|
2023-10-11 17:07:30 +02:00
|
|
|
std::vector<ClientParticleTexture> m_texpool;
|
2022-07-13 11:57:12 +02:00
|
|
|
size_t m_texcount;
|
2013-01-23 18:32:02 +01:00
|
|
|
std::vector<float> m_spawntimes;
|
2016-08-04 22:09:21 +02:00
|
|
|
u16 m_attached_id;
|
2012-12-31 19:33:36 +01:00
|
|
|
};
|
|
|
|
|
2015-01-05 18:34:59 +01:00
|
|
|
/**
|
|
|
|
* Class doing particle as well as their spawners handling
|
|
|
|
*/
|
|
|
|
class ParticleManager
|
|
|
|
{
|
|
|
|
friend class ParticleSpawner;
|
|
|
|
public:
|
|
|
|
ParticleManager(ClientEnvironment* env);
|
2023-10-11 17:07:30 +02:00
|
|
|
DISABLE_CLASS_COPY(ParticleManager)
|
2015-01-05 18:34:59 +01:00
|
|
|
~ParticleManager();
|
|
|
|
|
|
|
|
void step (float dtime);
|
|
|
|
|
2017-01-09 20:39:22 +01:00
|
|
|
void handleParticleEvent(ClientEvent *event, Client *client,
|
2017-06-26 20:11:17 +02:00
|
|
|
LocalPlayer *player);
|
2015-01-05 18:34:59 +01:00
|
|
|
|
2017-06-26 20:11:17 +02:00
|
|
|
void addDiggingParticles(IGameDef *gamedef, LocalPlayer *player, v3s16 pos,
|
|
|
|
const MapNode &n, const ContentFeatures &f);
|
2013-01-23 18:32:02 +01:00
|
|
|
|
2017-06-26 20:11:17 +02:00
|
|
|
void addNodeParticle(IGameDef *gamedef, LocalPlayer *player, v3s16 pos,
|
|
|
|
const MapNode &n, const ContentFeatures &f);
|
2013-01-23 18:32:02 +01:00
|
|
|
|
2022-07-13 11:57:12 +02:00
|
|
|
void reserveParticleSpace(size_t max_estimate);
|
|
|
|
|
2019-03-01 20:16:11 +01:00
|
|
|
/**
|
|
|
|
* This function is only used by client particle spawners
|
|
|
|
*
|
2020-05-22 13:23:25 +02:00
|
|
|
* We don't need to check the particle spawner list because client ID will
|
|
|
|
* never overlap (u64)
|
2019-03-01 20:16:11 +01:00
|
|
|
* @return new id
|
|
|
|
*/
|
|
|
|
u64 generateSpawnerId()
|
2019-02-26 08:53:53 +01:00
|
|
|
{
|
2019-03-01 20:16:11 +01:00
|
|
|
return m_next_particle_spawner_id++;
|
2019-02-26 08:53:53 +01:00
|
|
|
}
|
|
|
|
|
2015-01-05 18:34:59 +01:00
|
|
|
protected:
|
2020-05-22 13:23:25 +02:00
|
|
|
static bool getNodeParticleParams(const MapNode &n, const ContentFeatures &f,
|
|
|
|
ParticleParameters &p, video::ITexture **texture, v2f &texpos,
|
2020-05-22 14:17:03 +02:00
|
|
|
v2f &texsize, video::SColor *color, u8 tilenum = 0);
|
2020-05-22 13:23:25 +02:00
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
void addParticle(std::unique_ptr<Particle> toadd);
|
2012-12-31 19:33:36 +01:00
|
|
|
|
2015-01-05 18:34:59 +01:00
|
|
|
private:
|
2023-10-11 17:07:30 +02:00
|
|
|
void addParticleSpawner(u64 id, std::unique_ptr<ParticleSpawner> toadd);
|
2020-05-22 13:23:25 +02:00
|
|
|
void deleteParticleSpawner(u64 id);
|
2015-01-05 18:34:59 +01:00
|
|
|
|
2019-03-01 20:16:11 +01:00
|
|
|
void stepParticles(float dtime);
|
|
|
|
void stepSpawners(float dtime);
|
2015-01-05 18:34:59 +01:00
|
|
|
|
2019-03-01 20:16:11 +01:00
|
|
|
void clearAll();
|
2015-01-05 18:34:59 +01:00
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
std::vector<std::unique_ptr<Particle>> m_particles;
|
|
|
|
std::unordered_map<u64, std::unique_ptr<ParticleSpawner>> m_particle_spawners;
|
|
|
|
std::vector<std::unique_ptr<ParticleSpawner>> m_dying_particle_spawners;
|
2019-03-01 20:16:11 +01:00
|
|
|
// Start the particle spawner ids generated from here after u32_max. lower values are
|
|
|
|
// for server sent spawners.
|
|
|
|
u64 m_next_particle_spawner_id = U32_MAX + 1;
|
2015-01-05 18:34:59 +01:00
|
|
|
|
2023-10-11 17:07:30 +02:00
|
|
|
ClientEnvironment *m_env;
|
2017-06-06 16:29:28 +02:00
|
|
|
std::mutex m_particle_list_lock;
|
|
|
|
std::mutex m_spawner_list_lock;
|
2015-01-05 18:34:59 +01:00
|
|
|
};
|