X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fclient.cpp;h=03a710599a4af4b3c035910013e21a96bbbf407c;hb=666aae359310483b7ad0f2bba1f4c31d8a58c737;hp=06745eab0db8875af9ddc7c8db779779441599c6;hpb=037b2591971d752e67fa7d47095b996b3f56da5a;p=dragonfireclient.git diff --git a/src/client.cpp b/src/client.cpp index 06745eab0..03a710599 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -1,6 +1,6 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola 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 @@ -18,7 +18,6 @@ with this program; if not, write to the Free Software Foundation, Inc., */ #include "client.h" -#include "utility.h" #include #include "clientserver.h" #include "jmutexautolock.h" @@ -34,29 +33,28 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "nodemetadata.h" #include "nodedef.h" #include "itemdef.h" +#include "shader.h" #include #include "sha1.h" #include "base64.h" #include "clientmap.h" #include "filecache.h" #include "sound.h" -#include "utility_string.h" +#include "util/string.h" #include "hex.h" +#include "IMeshCache.h" +#include "util/serialize.h" +#include "config.h" + +#if USE_CURL +#include +#endif static std::string getMediaCacheDir() { return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "media"; } -struct MediaRequest -{ - std::string name; - - MediaRequest(const std::string &name_=""): - name(name_) - {} -}; - /* QueuedMeshUpdate */ @@ -221,18 +219,60 @@ void * MeshUpdateThread::Thread() return NULL; } +void * MediaFetchThread::Thread() +{ + ThreadStarted(); + + log_register_thread("MediaFetchThread"); + + DSTACK(__FUNCTION_NAME); + + BEGIN_DEBUG_EXCEPTION_HANDLER + + #if USE_CURL + CURL *curl; + CURLcode res; + for (std::list::iterator i = m_file_requests.begin(); + i != m_file_requests.end(); ++i) { + curl = curl_easy_init(); + assert(curl); + curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); + curl_easy_setopt(curl, CURLOPT_URL, (m_remote_url + i->name).c_str()); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, true); + std::ostringstream stream; + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_data); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, &stream); + res = curl_easy_perform(curl); + if (res == CURLE_OK) { + std::string data = stream.str(); + m_file_data.push_back(make_pair(i->name, data)); + } else { + m_failed.push_back(*i); + infostream << "cURL request failed for " << i->name << std::endl; + } + curl_easy_cleanup(curl); + } + #endif + + END_DEBUG_EXCEPTION_HANDLER(errorstream) + + return NULL; +} + Client::Client( IrrlichtDevice *device, const char *playername, std::string password, MapDrawControl &control, IWritableTextureSource *tsrc, + IWritableShaderSource *shsrc, IWritableItemDefManager *itemdef, IWritableNodeDefManager *nodedef, ISoundManager *sound, MtEventManager *event ): m_tsrc(tsrc), + m_shsrc(shsrc), m_itemdef(itemdef), m_nodedef(nodedef), m_sound(sound), @@ -259,13 +299,15 @@ Client::Client( m_password(password), m_access_denied(false), m_media_cache(getMediaCacheDir()), - m_media_receive_progress(0), - m_media_received(false), + m_media_receive_started(false), + m_media_count(0), + m_media_received_count(0), m_itemdef_received(false), m_nodedef_received(false), m_time_of_day_set(false), m_last_time_of_day_f(-1), m_time_of_day_update_timer(0), + m_recommended_send_interval(0.1), m_removed_sounds_check_timer(0) { m_packetcounter_timer = 0.0; @@ -291,6 +333,9 @@ Client::Client( m_env.addPlayer(player); } + + for (size_t i = 0; i < g_settings->getU16("media_fetch_threads"); ++i) + m_media_fetch_threads.push_back(new MediaFetchThread(this)); } Client::~Client() @@ -305,6 +350,28 @@ Client::~Client() sleep_ms(100); delete m_inventory_from_server; + + // Delete detached inventories + { + for(std::map::iterator + i = m_detached_inventories.begin(); + i != m_detached_inventories.end(); i++){ + delete i->second; + } + } + + for (std::list::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) @@ -490,8 +557,9 @@ void Client::step(float dtime) // [2] u8 SER_FMT_VER_HIGHEST // [3] u8[20] player_name // [23] u8[28] password (new in some version) - // [51] u16 client network protocol version (new in some version) - SharedBuffer data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2); + // [51] u16 minimum supported network protocol version (added sometime) + // [53] u16 maximum supported network protocol version (added later than the previous one) + SharedBuffer data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2+2); writeU16(&data[0], TOSERVER_INIT); writeU8(&data[2], SER_FMT_VER_HIGHEST); @@ -504,8 +572,8 @@ void Client::step(float dtime) memset((char*)&data[23], 0, PASSWORD_SIZE); snprintf((char*)&data[23], PASSWORD_SIZE, "%s", m_password.c_str()); - // This should be incremented in each version - writeU16(&data[51], PROTOCOL_VERSION); + writeU16(&data[51], CLIENT_PROTOCOL_VERSION_MIN); + writeU16(&data[53], CLIENT_PROTOCOL_VERSION_MAX); // Send as unreliable Send(0, data, false); @@ -526,7 +594,7 @@ void Client::step(float dtime) if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime)) { ScopeProfiler sp(g_profiler, "Client: map timer and unload"); - core::list deleted_blocks; + std::list deleted_blocks; m_env.getMap().timerUpdate(map_timer_and_unload_dtime, g_settings->getFloat("client_unload_unused_data_timeout"), &deleted_blocks); @@ -540,8 +608,8 @@ void Client::step(float dtime) NOTE: This loop is intentionally iterated the way it is. */ - core::list::Iterator i = deleted_blocks.begin(); - core::list sendlist; + std::list::iterator i = deleted_blocks.begin(); + std::list sendlist; for(;;) { if(sendlist.size() == 255 || i == deleted_blocks.end()) @@ -560,9 +628,9 @@ void Client::step(float dtime) writeU16(&reply[0], TOSERVER_DELETEDBLOCKS); reply[2] = sendlist.size(); u32 k = 0; - for(core::list::Iterator + for(std::list::iterator j = sendlist.begin(); - j != sendlist.end(); j++) + j != sendlist.end(); ++j) { writeV3S16(&reply[2+1+6*k], *j); k++; @@ -576,7 +644,7 @@ void Client::step(float dtime) } sendlist.push_back(*i); - i++; + ++i; } } @@ -647,7 +715,7 @@ void Client::step(float dtime) { float &counter = m_playerpos_send_timer; counter += dtime; - if(counter >= 0.2) + if(counter >= m_recommended_send_interval) { counter = 0.0; sendPlayerPos(); @@ -668,7 +736,7 @@ void Client::step(float dtime) < 0) + while(!m_mesh_update_thread.m_queue_out.empty()) { num_processed_meshes++; MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front(); @@ -715,6 +783,62 @@ void Client::step(float dtime) g_profiler->graphAdd("num_processed_meshes", num_processed_meshes); } + /* + Load fetched media + */ + if (m_media_receive_started) { + bool all_stopped = true; + for (std::list::iterator thread = m_media_fetch_threads.begin(); + thread != m_media_fetch_threads.end(); ++thread) { + all_stopped &= !(*thread)->IsRunning(); + while (!(*thread)->m_file_data.empty()) { + std::pair out = (*thread)->m_file_data.pop_front(); + ++m_media_received_count; + + bool success = loadMedia(out.second, out.first); + if(success){ + verbosestream<<"Client: Loaded received media: " + <<"\""<::iterator n; + n = m_media_name_sha1_map.find(out.first); + if(n == m_media_name_sha1_map.end()) + errorstream<<"The server sent a file that has not " + <<"been announced."< fetch_failed; + for (std::list::iterator thread = m_media_fetch_threads.begin(); + thread != m_media_fetch_threads.end(); ++thread) { + for (std::list::iterator request = (*thread)->m_failed.begin(); + request != (*thread)->m_failed.end(); ++request) + fetch_failed.push_back(*request); + (*thread)->m_failed.clear(); + } + if (fetch_failed.size() > 0) { + infostream << "Failed to remote-fetch " << fetch_failed.size() << " files. " + << "Requesting them the usual way." << std::endl; + request_media(fetch_failed); + } + } + } + /* If the server didn't update the inventory in a while, revert the local inventory (so the player notices the lag problem @@ -813,7 +937,7 @@ bool Client::loadMedia(const std::string &data, const std::string &filename) if(name != "") { verbosestream<<"Client: Attempting to load image " - <<"file \""<getFileSystem(); video::IVideoDriver *vdrv = m_device->getVideoDriver(); @@ -847,11 +971,45 @@ bool Client::loadMedia(const std::string &data, const std::string &filename) if(name != "") { verbosestream<<"Client: Attempting to load sound " - <<"file \""<loadSoundData(name, data); return true; } + const char *model_ext[] = { + ".x", ".b3d", ".md2", ".obj", + NULL + }; + name = removeStringEnd(filename, model_ext); + if(name != "") + { + verbosestream<<"Client: Storing model into Irrlicht: " + <<"\""<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); + + mesh = smgr->getMesh(rfile); + smgr->getMeshCache()->addMesh(filename.c_str(), mesh); + rfile->drop(); + return true; + } + errorstream<<"Client: Don't know how to load file \"" < &file_requests) +{ + std::ostringstream os(std::ios_base::binary); + writeU16(os, TOSERVER_REQUEST_MEDIA); + writeU16(os, file_requests.size()); + + for(std::list::const_iterator i = file_requests.begin(); + i != file_requests.end(); ++i) { + os<name); + } + + // Make data buffer + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); + infostream<<"Client: Sending media request list to server (" + <= 2+1+6+8+4) + { + // Get map seed + m_recommended_send_interval = readF1000(&data[2+1+6+8]); + infostream<<"Client: received recommended send interval " + <movement_acceleration_default = readF1000(is) * BS; + player->movement_acceleration_air = readF1000(is) * BS; + player->movement_acceleration_fast = readF1000(is) * BS; + player->movement_speed_walk = readF1000(is) * BS; + player->movement_speed_crouch = readF1000(is) * BS; + player->movement_speed_fast = readF1000(is) * BS; + player->movement_speed_climb = readF1000(is) * BS; + player->movement_speed_jump = readF1000(is) * BS; + player->movement_liquid_fluidity = readF1000(is) * BS; + player->movement_liquid_fluidity_smooth = readF1000(is) * BS; + player->movement_liquid_sink = readF1000(is) * BS; + player->movement_gravity = readF1000(is) * BS; + } else if(command == TOCLIENT_HP) { std::string datastring((char*)&data[2], datasize-2); @@ -1426,10 +1640,10 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) int num_files = readU16(is); - verbosestream<<"Client received TOCLIENT_ANNOUNCE_MEDIA (" - < file_requests; + std::list file_requests; for(int i=0; i::iterator cur = m_media_fetch_threads.begin(); + for(std::list::iterator i = file_requests.begin(); + i != file_requests.end(); ++i) { + (*cur)->m_file_requests.push_back(*i); + cur++; + if (cur == m_media_fetch_threads.end()) + cur = m_media_fetch_threads.begin(); } - */ - std::ostringstream os(std::ios_base::binary); - writeU16(os, TOSERVER_REQUEST_MEDIA); - writeU16(os, file_requests.size()); + for (std::list::iterator i = m_media_fetch_threads.begin(); + i != m_media_fetch_threads.end(); ++i) { + (*i)->m_remote_url = remote_media; + (*i)->Start(); + } + #endif - for(core::list::Iterator i = file_requests.begin(); - i != file_requests.end(); i++) { - os<name); + // notify server we received everything + std::ostringstream os(std::ios_base::binary); + writeU16(os, TOSERVER_RECEIVED_MEDIA); + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); } - - // Make data buffer - std::string s = os.str(); - SharedBuffer data((u8*)s.c_str(), s.size()); - // Send as reliable - Send(0, data, true); - infostream<<"Client: Sending media request list to server (" - <= 2) - m_media_receive_progress = (float)bunch_i / (float)(num_bunches - 1); - else - m_media_receive_progress = 1.0; - if(bunch_i == num_bunches - 1) - m_media_received = true; int num_files = readU32(is); infostream<<"Client: Received files: bunch "<inventory_formspec = deSerializeLongString(is); + } + else if(command == TOCLIENT_DETACHED_INVENTORY) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + std::string name = deSerializeString(is); + + infostream<<"Client: Detached inventory update: \""< 0) + inv = m_detached_inventories[name]; + else{ + inv = new Inventory(m_itemdef); + m_detached_inventories[name] = inv; + } + inv->deSerialize(is); + } + else if(command == TOCLIENT_SHOW_FORMSPEC) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + std::string formspec = deSerializeLongString(is); + std::string formname = deSerializeString(is); + + ClientEvent event; + event.type = CE_SHOW_FORMSPEC; + // pointer is required as event is a struct only! + // adding a std:string to a struct isn't possible + event.show_formspec.formspec = new std::string(formspec); + 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.add_particlespawner.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); + + 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; + 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) + 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 { infostream<<"Client: Ignoring unknown command " @@ -1764,6 +2183,29 @@ void Client::sendNodemetaFields(v3s16 p, const std::string &formname, Send(0, data, true); } +void Client::sendInventoryFields(const std::string &formname, + const std::map &fields) +{ + std::ostringstream os(std::ios_base::binary); + + writeU16(os, TOSERVER_INVENTORY_FIELDS); + os<::const_iterator + i = fields.begin(); i != fields.end(); i++){ + const std::string &name = i->first; + const std::string &value = i->second; + os< data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); +} + void Client::sendInventoryAction(InventoryAction *a) { std::ostringstream os(std::ios_base::binary); @@ -1880,10 +2322,24 @@ void Client::sendPlayerPos() { //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - Player *myplayer = m_env.getLocalPlayer(); + LocalPlayer *myplayer = m_env.getLocalPlayer(); if(myplayer == NULL) return; - + + // Save bandwidth by only updating position when something changed + if(myplayer->last_position == myplayer->getPosition() && + myplayer->last_speed == myplayer->getSpeed() && + myplayer->last_pitch == myplayer->getPitch() && + myplayer->last_yaw == myplayer->getYaw() && + myplayer->last_keyPressed == myplayer->keyPressed) + return; + + myplayer->last_position = myplayer->getPosition(); + myplayer->last_speed = myplayer->getSpeed(); + myplayer->last_pitch = myplayer->getPitch(); + myplayer->last_yaw = myplayer->getYaw(); + myplayer->last_keyPressed = myplayer->keyPressed; + u16 our_peer_id; { //JMutexAutoLock lock(m_con_mutex); //bulk comment-out @@ -1902,7 +2358,7 @@ void Client::sendPlayerPos() v3s32 speed(sf.X*100, sf.Y*100, sf.Z*100); s32 pitch = myplayer->getPitch() * 100; s32 yaw = myplayer->getYaw() * 100; - + u32 keyPressed=myplayer->keyPressed; /* Format: [0] u16 command @@ -1910,15 +2366,15 @@ void Client::sendPlayerPos() [2+12] v3s32 speed*100 [2+12+12] s32 pitch*100 [2+12+12+4] s32 yaw*100 + [2+12+12+4+4] u32 keyPressed */ - - SharedBuffer data(2+12+12+4+4); + SharedBuffer data(2+12+12+4+4+4); writeU16(&data[0], TOSERVER_PLAYERPOS); writeV3S32(&data[2], position); writeV3S32(&data[2+12], speed); writeS32(&data[2+12+12], pitch); - writeS32(&data[2+12+12+4], yaw); - + writeS32(&data[2+12+12+4], yaw); + writeU32(&data[2+12+12+4+4], keyPressed); // Send as unreliable Send(0, data, false); } @@ -1947,7 +2403,7 @@ void Client::sendPlayerItem(u16 item) void Client::removeNode(v3s16 p) { - core::map modified_blocks; + std::map modified_blocks; try { @@ -1961,12 +2417,11 @@ void Client::removeNode(v3s16 p) // add urgent task to update the modified node addUpdateMeshTaskForNode(p, false, true); - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - addUpdateMeshTaskWithEdge(p); + addUpdateMeshTaskWithEdge(i->first); } } @@ -1974,7 +2429,7 @@ void Client::addNode(v3s16 p, MapNode n) { TimeTaker timer1("Client::addNode()"); - core::map modified_blocks; + std::map modified_blocks; try { @@ -1984,12 +2439,11 @@ void Client::addNode(v3s16 p, MapNode n) catch(InvalidPositionException &e) {} - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - addUpdateMeshTaskWithEdge(p); + addUpdateMeshTaskWithEdge(i->first); } } @@ -2058,6 +2512,13 @@ Inventory* Client::getInventory(const InventoryLocation &loc) return meta->getInventory(); } break; + case InventoryLocation::DETACHED: + { + if(m_detached_inventories.count(loc.name) == 0) + return NULL; + return m_detached_inventories[loc.name]; + } + break; default: assert(0); } @@ -2082,7 +2543,7 @@ ClientActiveObject * Client::getSelectedActiveObject( core::line3d shootline_on_map ) { - core::array objects; + std::vector objects; m_env.getActiveObjects(from_pos_f_on_map, max_d, objects); @@ -2090,7 +2551,7 @@ ClientActiveObject * Client::getSelectedActiveObject( // Sort them. // After this, the closest object is the first in the array. - objects.sort(); + std::sort(objects.begin(), objects.end()); for(u32 i=0; i Client::getConnectedPlayerNames() +std::list Client::getConnectedPlayerNames() { - core::list players = m_env.getPlayers(true); - core::list playerNames; - for(core::list::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() @@ -2338,41 +2790,53 @@ ClientEvent Client::getClientEvent() void Client::afterContentReceived() { - verbosestream<<"Client::afterContentReceived() started"<rebuildImagesAndTextures(); // Update texture atlas - verbosestream<<"Updating texture atlas"<getBool("enable_texture_atlas")) m_tsrc->buildMainAtlas(this); + // Rebuild shaders + m_shsrc->rebuildShaders(); + // Update node aliases - verbosestream<<"Updating node aliases"<updateAliases(m_itemdef); // Update node textures - verbosestream<<"Updating node textures"<updateTextures(m_tsrc); - // Update item textures and meshes - verbosestream<<"Updating item textures and meshes"<updateTexturesAndMeshes(this); + // Preload item textures and meshes if configured to + if(g_settings->getBool("preload_item_visuals")) + { + verbosestream<<"Updating item textures and meshes"< names = m_itemdef->getAll(); + for(std::set::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); + } + } // Start mesh update thread after setting up content definitions - verbosestream<<"Starting mesh update thread"<