X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fclient.cpp;h=216d86cd412c6d0ffa0e9ae3cd1d8593614887e5;hb=69bd803a3221bf02672431390e672b0510695254;hp=9a056806b700f1b04a880abb64906b9a6c69ce65;hpb=756db8174aa6a05eb998cfcec8eb5127053c5ea9;p=oweals%2Fminetest.git

diff --git a/src/client.cpp b/src/client.cpp
index 9a056806b..216d86cd4 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -33,6 +33,7 @@ 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 <IFileSystem.h>
 #include "sha1.h"
 #include "base64.h"
@@ -42,21 +43,18 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/string.h"
 #include "hex.h"
 #include "IMeshCache.h"
+#include "util/serialize.h"
+#include "config.h"
+
+#if USE_CURL
+#include <curl/curl.h>
+#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 (core::list<MediaRequest>::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()
@@ -314,6 +359,10 @@ Client::~Client()
 			delete i->second;
 		}
 	}
+
+	for (core::list<MediaFetchThread*>::Iterator i = m_media_fetch_threads.begin();
+			i != m_media_fetch_threads.end(); i++)
+		delete *i;
 }
 
 void Client::connect(Address address)
@@ -499,8 +548,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<u8> 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<u8> data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2+2);
 			writeU16(&data[0], TOSERVER_INIT);
 			writeU8(&data[2], SER_FMT_VER_HIGHEST);
 
@@ -513,8 +563,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);
@@ -656,7 +706,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();
@@ -724,6 +774,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 (core::list<MediaFetchThread*>::Iterator thread = m_media_fetch_threads.begin();
+				thread != m_media_fetch_threads.end(); thread++) {
+			all_stopped &= !(*thread)->IsRunning();
+			while ((*thread)->m_file_data.size() > 0) {
+				std::pair <std::string, std::string> 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: "
+							<<"\""<<out.first<<"\". Caching."<<std::endl;
+				} else{
+					infostream<<"Client: Failed to load received media: "
+							<<"\""<<out.first<<"\". Not caching."<<std::endl;
+					continue;
+				}
+
+				bool did = fs::CreateAllDirs(getMediaCacheDir());
+				if(!did){
+					errorstream<<"Could not create media cache directory"
+							<<std::endl;
+				}
+
+				{
+					core::map<std::string, std::string>::Node *n;
+					n = m_media_name_sha1_map.find(out.first);
+					if(n == NULL)
+						errorstream<<"The server sent a file that has not "
+								<<"been announced."<<std::endl;
+					else
+						m_media_cache.update_sha1(out.second);
+				}
+			}
+		}
+		if (all_stopped) {
+			core::list<MediaRequest> fetch_failed;
+			for (core::list<MediaFetchThread*>::Iterator thread = m_media_fetch_threads.begin();
+					thread != m_media_fetch_threads.end(); thread++) {
+				for (core::list<MediaRequest>::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
@@ -901,6 +1007,34 @@ void Client::deletingPeer(con::Peer *peer, bool timeout)
 			<<"(timeout="<<timeout<<")"<<std::endl;
 }
 
+/*
+	u16 command
+	u16 number of files requested
+	for each file {
+		u16 length of name
+		string name
+	}
+*/
+void Client::request_media(const core::list<MediaRequest> &file_requests)
+{
+	std::ostringstream os(std::ios_base::binary);
+	writeU16(os, TOSERVER_REQUEST_MEDIA);
+	writeU16(os, file_requests.size());
+
+	for(core::list<MediaRequest>::ConstIterator i = file_requests.begin();
+			i != file_requests.end(); i++) {
+		os<<serializeString(i->name);
+	}
+
+	// Make data buffer
+	std::string s = os.str();
+	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+	// Send as reliable
+	Send(0, data, true);
+	infostream<<"Client: Sending media request list to server ("
+			<<file_requests.size()<<" files)"<<std::endl;
+}
+
 void Client::ReceiveAll()
 {
 	DSTACK(__FUNCTION_NAME);
@@ -1020,6 +1154,14 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 			m_map_seed = readU64(&data[2+1+6]);
 			infostream<<"Client: received map seed: "<<m_map_seed<<std::endl;
 		}
+
+		if(datasize >= 2+1+6+8+4)
+		{
+			// Get map seed
+			m_recommended_send_interval = readF1000(&data[2+1+6+8]);
+			infostream<<"Client: received recommended send interval "
+					<<m_recommended_send_interval<<std::endl;
+		}
 		
 		// Reply to server
 		u32 replysize = 2;
@@ -1457,8 +1599,8 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 
 		int num_files = readU16(is);
 		
-		verbosestream<<"Client received TOCLIENT_ANNOUNCE_MEDIA ("
-				<<num_files<<" files)"<<std::endl;
+		infostream<<"Client: Received media announcement: packet size: "
+				<<datasize<<std::endl;
 
 		core::list<MediaRequest> file_requests;
 
@@ -1500,37 +1642,52 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 			file_requests.push_back(MediaRequest(name));
 		}
 
-		ClientEvent event;
-		event.type = CE_TEXTURES_UPDATED;
-		m_client_event_queue.push_back(event);
+		std::string remote_media = "";
+		try {
+			remote_media = deSerializeString(is);
+		}
+		catch(SerializationError) {
+			// not supported by server or turned off
+		}
 
-		/*
-			u16 command
-			u16 number of files requested
-			for each file {
-				u16 length of name
-				string name
+		m_media_count = file_requests.size();
+		m_media_receive_started = true;
+
+		if (remote_media == "" || !USE_CURL) {
+			request_media(file_requests);
+		} else {
+			#if USE_CURL
+			core::list<MediaFetchThread*>::Iterator cur = m_media_fetch_threads.begin();
+			for(core::list<MediaRequest>::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 (core::list<MediaFetchThread*>::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<MediaRequest>::Iterator i = file_requests.begin();
-				i != file_requests.end(); i++) {
-			os<<serializeString(i->name);
+			// notify server we received everything
+			std::ostringstream os(std::ios_base::binary);
+			writeU16(os, TOSERVER_RECEIVED_MEDIA);
+			std::string s = os.str();
+			SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+			// Send as reliable
+			Send(0, data, true);
 		}
-
-		// Make data buffer
-		std::string s = os.str();
-		SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-		// Send as reliable
-		Send(0, data, true);
-		infostream<<"Client: Sending media request list to server ("
-				<<file_requests.size()<<" files)"<<std::endl;
+		ClientEvent event;
+		event.type = CE_TEXTURES_UPDATED;
+		m_client_event_queue.push_back(event);
 	}
 	else if(command == TOCLIENT_MEDIA)
 	{
+		if (m_media_count == 0)
+			return;
 		std::string datastring((char*)&data[2], datasize-2);
 		std::istringstream is(datastring, std::ios_base::binary);
 
@@ -1552,17 +1709,12 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 		*/
 		int num_bunches = readU16(is);
 		int bunch_i = readU16(is);
-		if(num_bunches >= 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 "<<bunch_i<<"/"
 				<<num_bunches<<" files="<<num_files
 				<<" size="<<datasize<<std::endl;
 		for(int i=0; i<num_files; i++){
+			m_media_received_count++;
 			std::string name = deSerializeString(is);
 			std::string data = deSerializeLongString(is);
 
@@ -1748,6 +1900,20 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 		}
 		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);
+
+		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);
+		m_client_event_queue.push_back(event);
+	}
 	else
 	{
 		infostream<<"Client: Ignoring unknown command "
@@ -1962,10 +2128,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
@@ -1984,7 +2164,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
@@ -1992,15 +2172,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<u8> data(2+12+12+4+4);
+	SharedBuffer<u8> 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);
 }
@@ -2427,41 +2607,53 @@ ClientEvent Client::getClientEvent()
 
 void Client::afterContentReceived()
 {
-	verbosestream<<"Client::afterContentReceived() started"<<std::endl;
+	infostream<<"Client::afterContentReceived() started"<<std::endl;
 	assert(m_itemdef_received);
 	assert(m_nodedef_received);
-	assert(m_media_received);
+	assert(texturesReceived());
 	
 	// remove the information about which checksum each texture
 	// ought to have
 	m_media_name_sha1_map.clear();
 
 	// Rebuild inherited images and recreate textures
-	verbosestream<<"Rebuilding images and textures"<<std::endl;
+	infostream<<"- Rebuilding images and textures"<<std::endl;
 	m_tsrc->rebuildImagesAndTextures();
 
 	// Update texture atlas
-	verbosestream<<"Updating texture atlas"<<std::endl;
+	infostream<<"- Updating texture atlas"<<std::endl;
 	if(g_settings->getBool("enable_texture_atlas"))
 		m_tsrc->buildMainAtlas(this);
 
+	// Rebuild shaders
+	m_shsrc->rebuildShaders();
+
 	// Update node aliases
-	verbosestream<<"Updating node aliases"<<std::endl;
+	infostream<<"- Updating node aliases"<<std::endl;
 	m_nodedef->updateAliases(m_itemdef);
 
 	// Update node textures
-	verbosestream<<"Updating node textures"<<std::endl;
+	infostream<<"- Updating node textures"<<std::endl;
 	m_nodedef->updateTextures(m_tsrc);
 
-	// Update item textures and meshes
-	verbosestream<<"Updating item textures and meshes"<<std::endl;
-	m_itemdef->updateTexturesAndMeshes(this);
+	// Preload item textures and meshes if configured to
+	if(g_settings->getBool("preload_item_visuals"))
+	{
+		verbosestream<<"Updating item textures and meshes"<<std::endl;
+		std::set<std::string> names = m_itemdef->getAll();
+		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);
+		}
+	}
 
 	// Start mesh update thread after setting up content definitions
-	verbosestream<<"Starting mesh update thread"<<std::endl;
+	infostream<<"- Starting mesh update thread"<<std::endl;
 	m_mesh_update_thread.Start();
 	
-	verbosestream<<"Client::afterContentReceived() done"<<std::endl;
+	infostream<<"Client::afterContentReceived() done"<<std::endl;
 }
 
 float Client::getRTT(void)
@@ -2492,6 +2684,10 @@ ITextureSource* Client::getTextureSource()
 {
 	return m_tsrc;
 }
+IShaderSource* Client::getShaderSource()
+{
+	return m_shsrc;
+}
 u16 Client::allocateUnknownNodeId(const std::string &name)
 {
 	errorstream<<"Client::allocateUnknownNodeId(): "