#include "mapblock.h"
#include "settings.h"
#include "profiler.h"
+#include "gettext.h"
#include "log.h"
#include "nodemetadata.h"
#include "nodedef.h"
#include "IMeshCache.h"
#include "util/serialize.h"
#include "config.h"
+#include "util/directiontables.h"
#if USE_CURL
#include <curl/curl.h>
m_mesh_update_thread.setRun(false);
while(m_mesh_update_thread.IsRunning())
sleep_ms(100);
+ while(!m_mesh_update_thread.m_queue_out.empty()) {
+ MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front();
+ delete r.mesh;
+ }
+
delete m_inventory_from_server;
for (std::list<MediaFetchThread*>::iterator i = m_media_fetch_threads.begin();
i != m_media_fetch_threads.end(); ++i)
delete *i;
+
+ // cleanup 3d model meshes on client shutdown
+ while (m_device->getSceneManager()->getMeshCache()->getMeshCount() != 0) {
+ scene::IAnimatedMesh * mesh =
+ m_device->getSceneManager()->getMeshCache()->getMeshByIndex(0);
+
+ if (mesh != NULL)
+ m_device->getSceneManager()->getMeshCache()->removeMesh(mesh);
+ }
}
void Client::connect(Address address)
// Replace with the new mesh
block->mesh = r.mesh;
+ } else {
+ delete r.mesh;
}
if(r.ack_block_to_server)
{
{
verbosestream<<"Client: Storing model into Irrlicht: "
<<"\""<<filename<<"\""<<std::endl;
+ scene::ISceneManager *smgr = m_device->getSceneManager();
+
+ //check if mesh was already cached
+ scene::IAnimatedMesh *mesh =
+ smgr->getMeshCache()->getMeshByName(filename.c_str());
+
+ if (mesh != NULL) {
+ errorstream << "Multiple models with name: " << filename.c_str() <<
+ " found replacing previous model!" << std::endl;
+
+ smgr->getMeshCache()->removeMesh(mesh);
+ mesh = 0;
+ }
io::IFileSystem *irrfs = m_device->getFileSystem();
io::IReadFile *rfile = irrfs->createMemoryReadFile(
*data_rw, data_rw.getSize(), filename.c_str());
assert(rfile);
- scene::ISceneManager *smgr = m_device->getSceneManager();
- scene::IAnimatedMesh *mesh = smgr->getMesh(rfile);
+ mesh = smgr->getMesh(rfile);
smgr->getMeshCache()->addMesh(filename.c_str(), mesh);
-
+ rfile->drop();
return true;
}
event.show_formspec.formname = new std::string(formname);
m_client_event_queue.push_back(event);
}
+ else if(command == TOCLIENT_SPAWN_PARTICLE)
+ {
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ v3f pos = readV3F1000(is);
+ v3f vel = readV3F1000(is);
+ v3f acc = readV3F1000(is);
+ float expirationtime = readF1000(is);
+ float size = readF1000(is);
+ bool collisiondetection = readU8(is);
+ std::string texture = deSerializeLongString(is);
+
+ ClientEvent event;
+ event.type = CE_SPAWN_PARTICLE;
+ event.spawn_particle.pos = new v3f (pos);
+ event.spawn_particle.vel = new v3f (vel);
+ event.spawn_particle.acc = new v3f (acc);
+
+ event.spawn_particle.expirationtime = expirationtime;
+ event.spawn_particle.size = size;
+ event.spawn_particle.collisiondetection =
+ collisiondetection;
+ event.spawn_particle.texture = new std::string(texture);
+
+ m_client_event_queue.push_back(event);
+ }
+ else if(command == TOCLIENT_ADD_PARTICLESPAWNER)
+ {
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ u16 amount = readU16(is);
+ float spawntime = readF1000(is);
+ v3f minpos = readV3F1000(is);
+ v3f maxpos = readV3F1000(is);
+ v3f minvel = readV3F1000(is);
+ v3f maxvel = readV3F1000(is);
+ v3f minacc = readV3F1000(is);
+ v3f maxacc = readV3F1000(is);
+ float minexptime = readF1000(is);
+ float maxexptime = readF1000(is);
+ float minsize = readF1000(is);
+ float maxsize = readF1000(is);
+ bool collisiondetection = readU8(is);
+ std::string texture = deSerializeLongString(is);
+ u32 id = readU32(is);
+
+ ClientEvent event;
+ event.type = CE_ADD_PARTICLESPAWNER;
+ event.add_particlespawner.amount = amount;
+ event.add_particlespawner.spawntime = spawntime;
+
+ event.add_particlespawner.minpos = new v3f (minpos);
+ event.add_particlespawner.maxpos = new v3f (maxpos);
+ event.add_particlespawner.minvel = new v3f (minvel);
+ event.add_particlespawner.maxvel = new v3f (maxvel);
+ event.add_particlespawner.minacc = new v3f (minacc);
+ event.add_particlespawner.maxacc = new v3f (maxacc);
+
+ event.add_particlespawner.minexptime = minexptime;
+ event.add_particlespawner.maxexptime = maxexptime;
+ event.add_particlespawner.minsize = minsize;
+ event.add_particlespawner.maxsize = maxsize;
+ event.add_particlespawner.collisiondetection = collisiondetection;
+ event.add_particlespawner.texture = new std::string(texture);
+ event.add_particlespawner.id = id;
+
+ m_client_event_queue.push_back(event);
+ }
+ else if(command == TOCLIENT_DELETE_PARTICLESPAWNER)
+ {
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ u32 id = readU16(is);
+
+ ClientEvent event;
+ event.type = CE_DELETE_PARTICLESPAWNER;
+ event.delete_particlespawner.id = id;
+
+ m_client_event_queue.push_back(event);
+ }
+ else if(command == TOCLIENT_HUDADD)
+ {
+ std::string datastring((char *)&data[2], datasize - 2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ u32 id = readU32(is);
+ u8 type = readU8(is);
+ v2f pos = readV2F1000(is);
+ std::string name = deSerializeString(is);
+ v2f scale = readV2F1000(is);
+ std::string text = deSerializeString(is);
+ u32 number = readU32(is);
+ u32 item = readU32(is);
+ u32 dir = readU32(is);
+ v2f align = readV2F1000(is);
+ v2f offset = readV2F1000(is);
+
+ ClientEvent event;
+ event.type = CE_HUDADD;
+ event.hudadd.id = id;
+ event.hudadd.type = type;
+ event.hudadd.pos = new v2f(pos);
+ event.hudadd.name = new std::string(name);
+ event.hudadd.scale = new v2f(scale);
+ event.hudadd.text = new std::string(text);
+ event.hudadd.number = number;
+ event.hudadd.item = item;
+ event.hudadd.dir = dir;
+ event.hudadd.align = new v2f(align);
+ event.hudadd.offset = new v2f(offset);
+ m_client_event_queue.push_back(event);
+ }
+ else if(command == TOCLIENT_HUDRM)
+ {
+ std::string datastring((char *)&data[2], datasize - 2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ u32 id = readU32(is);
+
+ ClientEvent event;
+ event.type = CE_HUDRM;
+ event.hudrm.id = id;
+ m_client_event_queue.push_back(event);
+ }
+ else if(command == TOCLIENT_HUDCHANGE)
+ {
+ std::string sdata;
+ v2f v2fdata;
+ u32 intdata = 0;
+
+ std::string datastring((char *)&data[2], datasize - 2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ u32 id = readU32(is);
+ u8 stat = (HudElementStat)readU8(is);
+
+ if (stat == HUD_STAT_POS || stat == HUD_STAT_SCALE ||
+ stat == HUD_STAT_ALIGN || stat == HUD_STAT_OFFSET)
+ v2fdata = readV2F1000(is);
+ else if (stat == HUD_STAT_NAME || stat == HUD_STAT_TEXT)
+ sdata = deSerializeString(is);
+ else
+ intdata = readU32(is);
+
+ ClientEvent event;
+ event.type = CE_HUDCHANGE;
+ event.hudchange.id = id;
+ event.hudchange.stat = (HudElementStat)stat;
+ event.hudchange.v2fdata = new v2f(v2fdata);
+ event.hudchange.sdata = new std::string(sdata);
+ event.hudchange.data = intdata;
+ m_client_event_queue.push_back(event);
+ }
+ else if(command == TOCLIENT_HUD_SET_FLAGS)
+ {
+ std::string datastring((char *)&data[2], datasize - 2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ Player *player = m_env.getLocalPlayer();
+ assert(player != NULL);
+
+ u32 flags = readU32(is);
+ u32 mask = readU32(is);
+
+ player->hud_flags &= ~mask;
+ player->hud_flags |= flags;
+ }
else
{
infostream<<"Client: Ignoring unknown command "
Predict some local inventory changes
*/
a->clientApply(this, this);
+
+ // Remove it
+ delete a;
}
ClientActiveObject * Client::getSelectedActiveObject(
<<std::endl;*/
}
-std::list<std::wstring> Client::getConnectedPlayerNames()
+std::list<std::string> Client::getConnectedPlayerNames()
{
- std::list<Player*> players = m_env.getPlayers(true);
- std::list<std::wstring> playerNames;
- for(std::list<Player*>::iterator
- i = players.begin();
- i != players.end(); ++i)
- {
- Player *player = *i;
- playerNames.push_back(narrow_to_wide(player->getName()));
- }
- return playerNames;
+ return m_env.getPlayerNames();
}
float Client::getAnimationTime()
}
catch(InvalidPositionException &e){}
// Leading edge
- try{
- v3s16 p = blockpos + v3s16(-1,0,0);
- addUpdateMeshTask(p, false, urgent);
- }
- catch(InvalidPositionException &e){}
- try{
- v3s16 p = blockpos + v3s16(0,-1,0);
- addUpdateMeshTask(p, false, urgent);
- }
- catch(InvalidPositionException &e){}
- try{
- v3s16 p = blockpos + v3s16(0,0,-1);
- addUpdateMeshTask(p, false, urgent);
+ for (int i=0;i<6;i++)
+ {
+ try{
+ v3s16 p = blockpos + g_6dirs[i];
+ addUpdateMeshTask(p, false, urgent);
+ }
+ catch(InvalidPositionException &e){}
}
- catch(InvalidPositionException &e){}
}
void Client::addUpdateMeshTaskForNode(v3s16 nodepos, bool ack_to_server, bool urgent)
return m_client_event_queue.pop_front();
}
-void Client::afterContentReceived()
+void draw_load_screen(const std::wstring &text,
+ IrrlichtDevice* device, gui::IGUIFont* font,
+ float dtime=0 ,int percent=0, bool clouds=true);
+void Client::afterContentReceived(IrrlichtDevice *device, gui::IGUIFont* font)
{
infostream<<"Client::afterContentReceived() started"<<std::endl;
assert(m_itemdef_received);
if(g_settings->getBool("preload_item_visuals"))
{
verbosestream<<"Updating item textures and meshes"<<std::endl;
+ wchar_t* text = wgettext("Item textures...");
+ draw_load_screen(text,device,font,0,0);
std::set<std::string> names = m_itemdef->getAll();
+ size_t size = names.size();
+ size_t count = 0;
+ int percent = 0;
for(std::set<std::string>::const_iterator
i = names.begin(); i != names.end(); ++i){
// Asking for these caches the result
m_itemdef->getInventoryTexture(*i, this);
m_itemdef->getWieldMesh(*i, this);
+ count++;
+ percent = count*100/size;
+ if (count%50 == 0) // only update every 50 item
+ draw_load_screen(text,device,font,0,percent);
}
+ delete[] text;
}
// Start mesh update thread after setting up content definitions