/*
Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2020 sfan5 <sfan5@live.de>
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
*/
#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 "gamedef.h"
-#include "collision.h"
-#include <stdlib.h>
-#include "util/numeric.h"
-#include "light.h"
-#include "environment.h"
-#include "clientmap.h"
-#include "mapnode.h"
-
-Particle::Particle(
- IGameDef *gamedef,
- 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)
-{
- // Misc
- m_gamedef = gamedef;
-
- // 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);
+#include <type_traits>
+using namespace ParticleParamTypes;
+
+#define PARAM_PVFN(n) ParticleParamTypes::n##ParameterValue
+v2f PARAM_PVFN(pick) (float* f, const v2f a, const v2f b) {
+ return v2f(
+ numericalBlend(f[0], a.X, b.X),
+ numericalBlend(f[1], a.Y, b.Y)
+ );
}
-Particle::~Particle()
-{
+v3f PARAM_PVFN(pick) (float* f, const v3f a, const v3f b) {
+ return v3f(
+ numericalBlend(f[0], a.X, b.X),
+ numericalBlend(f[1], a.Y, b.Y),
+ numericalBlend(f[2], a.Z, b.Z)
+ );
}
-void Particle::OnRegisterSceneNode()
+v2f PARAM_PVFN(interpolate) (float fac, const v2f a, const v2f b)
+ { return b.getInterpolated(a, fac); }
+v3f PARAM_PVFN(interpolate) (float fac, const v3f a, const v3f b)
+ { return b.getInterpolated(a, fac); }
+
+#define PARAM_DEF_SRZR(T, wr, rd) \
+ void PARAM_PVFN(serialize) (std::ostream& os, T v) {wr(os,v); } \
+ void PARAM_PVFN(deSerialize)(std::istream& is, T& v) {v = rd(is);}
+
+
+#define PARAM_DEF_NUM(T, wr, rd) PARAM_DEF_SRZR(T, wr, rd) \
+ T PARAM_PVFN(interpolate)(float fac, const T a, const T b) \
+ { return numericalBlend<T>(fac,a,b); } \
+ T PARAM_PVFN(pick) (float* f, const T a, const T b) \
+ { return numericalBlend<T>(f[0],a,b); }
+
+PARAM_DEF_NUM(u8, writeU8, readU8); PARAM_DEF_NUM(s8, writeS8, readS8);
+PARAM_DEF_NUM(u16, writeU16, readU16); PARAM_DEF_NUM(s16, writeS16, readS16);
+PARAM_DEF_NUM(u32, writeU32, readU32); PARAM_DEF_NUM(s32, writeS32, readS32);
+PARAM_DEF_NUM(f32, writeF32, readF32);
+PARAM_DEF_SRZR(v2f, writeV2F32, readV2F32);
+PARAM_DEF_SRZR(v3f, writeV3F32, readV3F32);
+
+enum class ParticleTextureFlags : u8 {
+ /* each value specifies a bit in a bitmask; if the maximum value
+ * goes above 1<<7 the type of the flags field must be changed
+ * from u8, which will necessitate a protocol change! */
+
+ // the first bit indicates whether the texture is animated
+ animated = 1,
+
+ /* the next three bits indicate the blending mode of the texture
+ * blendmode is encoded by (flags |= (u8)blend << 1); retrieve with
+ * (flags & ParticleTextureFlags::blend) >> 1. note that the third
+ * bit is currently reserved for adding more blend modes in the future */
+ blend = 0x7 << 1,
+};
+
+/* define some shorthand so we don't have to repeat ourselves or use
+ * decltype everywhere */
+using FlagT = std::underlying_type_t<ParticleTextureFlags>;
+
+void ServerParticleTexture::serialize(std::ostream &os, u16 protocol_ver, bool newPropertiesOnly) const
{
- if (IsVisible)
- {
- SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
- SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
- }
-
- ISceneNode::OnRegisterSceneNode();
+ /* newPropertiesOnly is used to de/serialize parameters of the legacy texture
+ * field, which are encoded separately from the texspec string */
+ FlagT flags = 0;
+ if (animated)
+ flags |= FlagT(ParticleTextureFlags::animated);
+ if (blendmode != BlendMode::alpha)
+ flags |= FlagT(blendmode) << 1;
+ serializeParameterValue(os, flags);
+
+ alpha.serialize(os);
+ scale.serialize(os);
+ if (!newPropertiesOnly)
+ os << serializeString32(string);
+
+ if (animated)
+ animation.serialize(os, protocol_ver);
}
-void Particle::render()
+void ServerParticleTexture::deSerialize(std::istream &is, u16 protocol_ver, bool newPropertiesOnly)
{
- // 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);
-}
+ FlagT flags = 0;
+ deSerializeParameterValue(is, flags);
-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.getClientMap(), m_gamedef,
- 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(), m_gamedef->ndef());
- }
- catch(InvalidPositionException &e){
- light = blend_light(env.getDayNightRatio(), LIGHT_SUN, 0);
- }
- m_light = decode_light(light);
-}
+ animated = !!(flags & FlagT(ParticleTextureFlags::animated));
+ blendmode = BlendMode((flags & FlagT(ParticleTextureFlags::blend)) >> 1);
-std::vector<Particle*> all_particles;
+ alpha.deSerialize(is);
+ scale.deSerialize(is);
+ if (!newPropertiesOnly)
+ string = deSerializeString32(is);
-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++;
- }
- }
+ if (animated)
+ animation.deSerialize(is, protocol_ver);
}
-void addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleParameters::serialize(std::ostream &os, u16 protocol_ver) const
{
- for (u16 j = 0; j < 32; j++) // set the amount of particles here
- {
- addNodeParticle(gamedef, smgr, player, pos, tiles);
- }
+ writeV3F32(os, pos);
+ writeV3F32(os, vel);
+ writeV3F32(os, acc);
+ writeF32(os, expirationtime);
+ writeF32(os, size);
+ writeU8(os, collisiondetection);
+ os << serializeString32(texture.string);
+ writeU8(os, vertical);
+ writeU8(os, collision_removal);
+ animation.serialize(os, protocol_ver);
+ writeU8(os, glow);
+ writeU8(os, object_collision);
+ writeU16(os, node.param0);
+ writeU8(os, node.param2);
+ writeU8(os, node_tile);
+ writeV3F32(os, drag);
+ jitter.serialize(os);
+ bounce.serialize(os);
}
-void addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+template <typename T, T (reader)(std::istream& is)>
+inline bool streamEndsBeforeParam(T& val, std::istream& is)
{
- addNodeParticle(gamedef, smgr, player, pos, tiles);
+ // This is kinda awful
+ T tmp = reader(is);
+ if (is.eof())
+ return true;
+ val = tmp;
+ return false;
}
-// add a particle of a node
-// used by digging and punching particles
-void addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr, LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleParameters::deSerialize(std::istream &is, u16 protocol_ver)
{
- // Texture
- u8 texid = myrand_range(0,5);
- AtlasPointer ap = 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(
- gamedef,
- smgr,
- player,
- 0,
- particlepos,
- velocity,
- acceleration,
- rand()%100/100., // expiration time
- visual_size,
- ap);
-
- all_particles.push_back(particle);
+ pos = readV3F32(is);
+ vel = readV3F32(is);
+ acc = readV3F32(is);
+ expirationtime = readF32(is);
+ size = readF32(is);
+ collisiondetection = readU8(is);
+ texture.string = deSerializeString32(is);
+ vertical = readU8(is);
+ collision_removal = readU8(is);
+ animation.deSerialize(is, protocol_ver);
+ glow = readU8(is);
+ object_collision = readU8(is);
+
+ if (streamEndsBeforeParam<u16, readU16>(node.param0, is))
+ return;
+ node.param2 = readU8(is);
+ node_tile = readU8(is);
+
+ if (streamEndsBeforeParam<v3f, readV3F32>(drag, is))
+ return;
+ jitter.deSerialize(is);
+ bounce.deSerialize(is);
}