#include "filecache.h"
#include "sound.h"
-static std::string getTextureCacheDir()
+static std::string getMediaCacheDir()
{
- return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "textures";
+ return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "media";
}
-struct TextureRequest
+struct MediaRequest
{
std::string name;
- TextureRequest(const std::string &name_=""):
+ MediaRequest(const std::string &name_=""):
name(name_)
{}
};
m_map_seed(0),
m_password(password),
m_access_denied(false),
- m_texture_cache(getTextureCacheDir()),
- m_texture_receive_progress(0),
- m_textures_received(false),
+ m_media_cache(getMediaCacheDir()),
+ m_media_receive_progress(0),
+ m_media_received(false),
m_itemdef_received(false),
m_nodedef_received(false),
m_time_of_day_set(false),
event.deathscreen.camera_point_target_z = camera_point_target.Z;
m_client_event_queue.push_back(event);
}
- else if(command == TOCLIENT_ANNOUNCE_TEXTURES)
+ else if(command == TOCLIENT_ANNOUNCE_MEDIA)
{
io::IFileSystem *irrfs = m_device->getFileSystem();
video::IVideoDriver *vdrv = m_device->getVideoDriver();
// updating content definitions
assert(!m_mesh_update_thread.IsRunning());
- int num_textures = readU16(is);
+ int num_files = readU16(is);
+
+ verbosestream<<"Client received TOCLIENT_ANNOUNCE_MEDIA ("
+ <<num_files<<" files)"<<std::endl;
- core::list<TextureRequest> texture_requests;
+ core::list<MediaRequest> file_requests;
- for(int i=0; i<num_textures; i++){
+ for(int i=0; i<num_files; i++){
- bool texture_found = false;
+ bool file_found = false;
- //read texture from cache
+ //read file from cache
std::string name = deSerializeString(is);
- std::string sha1_texture = deSerializeString(is);
+ std::string sha1_file = deSerializeString(is);
- // if name contains illegal characters, ignore the texture
+ // if name contains illegal characters, ignore the file
if(!string_allowed(name, TEXTURENAME_ALLOWED_CHARS)){
- errorstream<<"Client: ignoring illegal texture name "
+ errorstream<<"Client: ignoring illegal file name "
<<"sent by server: \""<<name<<"\""<<std::endl;
continue;
}
- std::string sha1_decoded = base64_decode(sha1_texture);
+ std::string sha1_decoded = base64_decode(sha1_file);
std::ostringstream tmp_os(std::ios_base::binary);
- bool tex_in_cache = m_texture_cache.loadByChecksum(name,
- tmp_os, sha1_decoded);
- m_texture_name_sha1_map.set(name, sha1_decoded);
-
- if(tex_in_cache) {
+ bool file_in_cache = m_media_cache.loadByChecksum(sha1_decoded,
+ tmp_os);
+ m_media_name_sha1_map.set(name, sha1_decoded);
+ if(file_in_cache)
+ {
SHA1 sha1;
sha1.addBytes(tmp_os.str().c_str(), tmp_os.str().length());
std::string digest_string = base64_encode(digest, 20);
- if (digest_string == sha1_texture) {
+ if (digest_string == sha1_file) {
// Silly irrlicht's const-incorrectness
Buffer<char> data_rw(tmp_os.str().c_str(), tmp_os.str().size());
video::IImage *img = vdrv->createImageFromFile(rfile);
if(!img){
infostream<<"Client: Cannot create image from data of "
- <<"received texture \""<<name<<"\""<<std::endl;
+ <<"received file \""<<name<<"\""<<std::endl;
rfile->drop();
}
else {
img->drop();
rfile->drop();
- texture_found = true;
+ file_found = true;
}
}
else {
- infostream<<"Client::Texture cached sha1 hash not matching server hash: "
- <<name << ": server ->"<<sha1_texture <<" client -> "<<digest_string<<std::endl;
+ infostream<<"Client::Media cached sha1 hash not matching server hash: "
+ <<name << ": server ->"<<sha1_file <<" client -> "<<digest_string<<std::endl;
}
free(digest);
}
- //add texture request
- if (!texture_found) {
- infostream<<"Client: Adding texture to request list: \""
+ //add file request
+ if (!file_found) {
+ infostream<<"Client: Adding file to request list: \""
<<name<<"\""<<std::endl;
- texture_requests.push_back(TextureRequest(name));
+ file_requests.push_back(MediaRequest(name));
}
}
m_client_event_queue.push_back(event);
- //send Texture request
+ //send Media request
/*
u16 command
- u16 number of textures requested
- for each texture {
+ u16 number of files requested
+ for each file {
u16 length of name
string name
}
// Write command
- writeU16(buf, TOSERVER_REQUEST_TEXTURES);
+ writeU16(buf, TOSERVER_REQUEST_MEDIA);
os.write((char*)buf, 2);
- writeU16(buf,texture_requests.size());
+ writeU16(buf,file_requests.size());
os.write((char*)buf, 2);
- for(core::list<TextureRequest>::Iterator i = texture_requests.begin();
- i != texture_requests.end(); i++) {
+ for(core::list<MediaRequest>::Iterator i = file_requests.begin();
+ i != file_requests.end(); i++) {
os<<serializeString(i->name);
}
SharedBuffer<u8> data((u8*)s.c_str(), s.size());
// Send as reliable
Send(0, data, true);
- infostream<<"Client: Sending request list to server " <<std::endl;
+ infostream<<"Client: Sending media request list to server ("
+ <<file_requests.size()<<" files)"<<std::endl;
}
- else if(command == TOCLIENT_TEXTURES)
+ else if(command == TOCLIENT_MEDIA)
{
+ verbosestream<<"Client received TOCLIENT_MEDIA"<<std::endl;
+
io::IFileSystem *irrfs = m_device->getFileSystem();
video::IVideoDriver *vdrv = m_device->getVideoDriver();
/*
u16 command
- u16 total number of texture bunches
+ u16 total number of file bunches
u16 index of this bunch
- u32 number of textures in this bunch
- for each texture {
+ u32 number of files in this bunch
+ for each file {
u16 length of name
string name
u32 length of data
*/
int num_bunches = readU16(is);
int bunch_i = readU16(is);
- m_texture_receive_progress = (float)bunch_i / (float)(num_bunches - 1);
+ m_media_receive_progress = (float)bunch_i / (float)(num_bunches - 1);
if(bunch_i == num_bunches - 1)
- m_textures_received = true;
- int num_textures = readU32(is);
- infostream<<"Client: Received textures: bunch "<<bunch_i<<"/"
- <<num_bunches<<" textures="<<num_textures
+ 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_textures; i++){
+ for(int i=0; i<num_files; i++){
std::string name = deSerializeString(is);
std::string data = deSerializeLongString(is);
- // if name contains illegal characters, ignore the texture
+ // if name contains illegal characters, ignore the file
if(!string_allowed(name, TEXTURENAME_ALLOWED_CHARS)){
- errorstream<<"Client: ignoring illegal texture name "
+ errorstream<<"Client: ignoring illegal file name "
<<"sent by server: \""<<name<<"\""<<std::endl;
continue;
}
video::IImage *img = vdrv->createImageFromFile(rfile);
if(!img){
errorstream<<"Client: Cannot create image from data of "
- <<"received texture \""<<name<<"\""<<std::endl;
+ <<"received file \""<<name<<"\""<<std::endl;
rfile->drop();
continue;
}
- fs::CreateAllDirs(getTextureCacheDir());
+ 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_texture_name_sha1_map.find(name);
+ n = m_media_name_sha1_map.find(name);
if(n == NULL)
- errorstream<<"The server sent a texture that has not been announced."
- <<std::endl;
+ errorstream<<"The server sent a file that has not "
+ <<"been announced."<<std::endl;
else
- m_texture_cache.updateByChecksum(name,
- data, n->getValue());
+ m_media_cache.updateByChecksum(n->getValue(), data);
}
m_tsrc->insertSourceImage(name, img);
{
assert(m_itemdef_received);
assert(m_nodedef_received);
- assert(m_textures_received);
+ assert(m_media_received);
// remove the information about which checksum each texture
// ought to have
- m_texture_name_sha1_map.clear();
+ m_media_name_sha1_map.clear();
// Rebuild inherited images and recreate textures
m_tsrc->rebuildImagesAndTextures();
std::wstring accessDeniedReason()
{ return m_access_denied_reason; }
- float textureReceiveProgress()
- { return m_texture_receive_progress; }
+ float mediaReceiveProgress()
+ { return m_media_receive_progress; }
bool texturesReceived()
- { return m_textures_received; }
+ { return m_media_received; }
bool itemdefReceived()
{ return m_itemdef_received; }
bool nodedefReceived()
bool m_access_denied;
std::wstring m_access_denied_reason;
Queue<ClientEvent> m_client_event_queue;
- FileCache m_texture_cache;
- // a map of the name and SHA1 checksum of each texture;
- // cleared after content has been recieved
- core::map<std::string, std::string> m_texture_name_sha1_map;
- float m_texture_receive_progress;
- bool m_textures_received;
+ FileCache m_media_cache;
+ // Mapping from media file name to SHA1 checksum
+ core::map<std::string, std::string> m_media_name_sha1_map;
+ float m_media_receive_progress;
+ bool m_media_received;
bool m_itemdef_received;
bool m_nodedef_received;
friend class FarMesh;
PROTOCOL_VERSION 3:
Base for writing changes here
PROTOCOL_VERSION 4:
- Add TOCLIENT_TEXTURES
+ Add TOCLIENT_MEDIA
Add TOCLIENT_TOOLDEF
Add TOCLIENT_NODEDEF
Add TOCLIENT_CRAFTITEMDEF
v3f1000 camera point target (to point the death cause or whatever)
*/
- TOCLIENT_TEXTURES = 0x38,
+ TOCLIENT_MEDIA = 0x38,
/*
u16 command
u16 total number of texture bunches
u16 index of this bunch
- u32 number of textures in this bunch
- for each texture {
+ u32 number of files in this bunch
+ for each file {
u16 length of name
string name
u32 length of data
serialized CraftiItemDefManager
*/
- TOCLIENT_ANNOUNCE_TEXTURES = 0x3c,
+ TOCLIENT_ANNOUNCE_MEDIA = 0x3c,
/*
u16 command
- u32 number of textures
+ u32 number of files
for each texture {
u16 length of name
string name
s32[len] sound_id
*/
- TOSERVER_REQUEST_TEXTURES = 0x40,
+ TOSERVER_REQUEST_MEDIA = 0x40,
/*
u16 command
- u16 number of textures requested
- for each texture {
+ u16 number of files requested
+ for each file {
u16 length of name
string name
}
#include <string>
#include <iostream>
-bool FileCache::loadByPath(const std::string &name, std::ostream &os,
- const std::string &path)
+bool FileCache::loadByPath(const std::string &path, std::ostream &os)
{
std::ifstream fis(path.c_str(), std::ios_base::binary);
if(!fis.good()){
- infostream<<"FileCache: File not found in cache: "
- <<name << " expected it at: "<<path<<std::endl;
+ verbosestream<<"FileCache: File not found in cache: "
+ <<path<<std::endl;
return false;
}
}
}
if(bad){
- infostream<<"FileCache: Failed to read file from cache: \""
- <<path<<"\""<<std::endl;
+ errorstream<<"FileCache: Failed to read file from cache: \""
+ <<path<<"\""<<std::endl;
}
return !bad;
}
-bool FileCache::updateByPath(const std::string &name, const std::string &data,
- const std::string &path)
+bool FileCache::updateByPath(const std::string &path, const std::string &data)
{
std::ofstream file(path.c_str(), std::ios_base::binary |
std::ios_base::trunc);
if(!file.good())
{
errorstream<<"FileCache: Can't write to file at "
- <<path<<std::endl;
+ <<path<<std::endl;
return false;
}
bool FileCache::loadByName(const std::string &name, std::ostream &os)
{
std::string path = m_dir + DIR_DELIM + name;
- return loadByPath(name, os, path);
+ return loadByPath(path, os);
}
bool FileCache::updateByName(const std::string &name, const std::string &data)
{
std::string path = m_dir + DIR_DELIM + name;
- return updateByPath(name, data, path);
+ return updateByPath(path, data);
}
-std::string FileCache::getPathFromChecksum(const std::string &name,
- const std::string &checksum)
+std::string FileCache::getPathFromChecksum(const std::string &checksum)
{
std::string checksum_hex = hex_encode(checksum.c_str(), checksum.length());
- size_t dot = name.find_last_of('.');;
- std::string ext = (dot == std::string::npos)? "" :
- name.substr(dot, std::string::npos);
- return m_dir + DIR_DELIM + checksum_hex + ext;
+ return m_dir + DIR_DELIM + checksum_hex;
}
-bool FileCache::loadByChecksum(const std::string &name, std::ostream &os,
- const std::string &checksum)
+bool FileCache::loadByChecksum(const std::string &checksum, std::ostream &os)
{
- std::string path = getPathFromChecksum(name, checksum);
- return loadByPath(name, os, path);
+ std::string path = getPathFromChecksum(checksum);
+ return loadByPath(path, os);
}
-bool FileCache::updateByChecksum(const std::string &name,
- const std::string &data, const std::string &checksum)
+bool FileCache::updateByChecksum(const std::string &checksum,
+ const std::string &data)
{
- std::string path = getPathFromChecksum(name, checksum);
- return updateByPath(name, data, path);
+ std::string path = getPathFromChecksum(checksum);
+ return updateByPath(path, data);
}
Loads a file based on a check sum, which may be any kind of
rather unique byte sequence. Returns true, if the file could
be written into os, false otherwise.
- A file name is required to give the disk file a name that
- has the right file name extension (e.g. ".png").
*/
- bool loadByChecksum(const std::string &name, std::ostream &os,
- const std::string &checksum);
+ bool loadByChecksum(const std::string &checksum, std::ostream &os);
/*
Stores a file in the cache based on its checksum.
Returns true on success, false otherwise.
*/
- bool updateByChecksum(const std::string &name, const std::string &data,
- const std::string &checksum);
+ bool updateByChecksum(const std::string &checksum, const std::string &data);
private:
std::string m_dir;
- bool loadByPath(const std::string &name, std::ostream &os,
- const std::string &path);
- bool updateByPath(const std::string &name, const std::string &data,
- const std::string &path);
- std::string getPathFromChecksum(const std::string &name,
- const std::string &checksum);
+ bool loadByPath(const std::string &path, std::ostream &os);
+ bool updateByPath(const std::string &path, const std::string &data);
+ std::string getPathFromChecksum(const std::string &checksum);
};
#endif
#include "clientmap.h"
#include "sky.h"
#include "sound.h"
-#if USE_AUDIO
+#if USE_SOUND
#include "sound_openal.h"
#endif
#include "event_manager.h"
// Sound manager
ISoundManager *sound = NULL;
bool sound_is_dummy = false;
-#if USE_AUDIO
+#if USE_SOUND
infostream<<"Attempting to use OpenAL audio"<<std::endl;
sound = createOpenALSoundManager(&soundfetcher);
if(!sound)
ss<<L" Item definitions\n";
ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
ss<<L" Node definitions\n";
- //ss<<(client.texturesReceived()?L"[X]":L"[ ]");
- ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
- ss<<L" Textures\n";
+ ss<<L"["<<(int)(client.mediaReceiveProgress()*100+0.5)<<L"%] ";
+ ss<<L" Media\n";
draw_load_screen(ss.str(), driver, font);
}
// Read Textures and calculate sha1 sums
- PrepareTextures();
+ fillMediaCache();
// Apply item aliases in the node definition manager
m_nodedef->updateAliases(m_itemdef);
SendNodeDef(m_con, peer_id, m_nodedef);
// Send texture announcement
- SendTextureAnnouncement(peer_id);
+ sendMediaAnnouncement(peer_id);
// Send player info to all players
//SendPlayerInfos();
// ActiveObject is added to environment in AsyncRunStep after
// the previous addition has been succesfully removed
}
- else if(command == TOSERVER_REQUEST_TEXTURES) {
+ else if(command == TOSERVER_REQUEST_MEDIA) {
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
- core::list<TextureRequest> tosend;
- u16 numtextures = readU16(is);
+ core::list<MediaRequest> tosend;
+ u16 numfiles = readU16(is);
- infostream<<"Sending "<<numtextures<<" textures to "
+ infostream<<"Sending "<<numfiles<<" files to "
<<getPlayerName(peer_id)<<std::endl;
- verbosestream<<"TOSERVER_REQUEST_TEXTURES: "<<std::endl;
+ verbosestream<<"TOSERVER_REQUEST_MEDIA: "<<std::endl;
- for(int i = 0; i < numtextures; i++) {
+ for(int i = 0; i < numfiles; i++) {
std::string name = deSerializeString(is);
- tosend.push_back(TextureRequest(name));
- verbosestream<<"TOSERVER_REQUEST_TEXTURES: requested texture "
+ tosend.push_back(MediaRequest(name));
+ verbosestream<<"TOSERVER_REQUEST_MEDIA: requested file "
<<name<<std::endl;
}
- SendTexturesRequested(peer_id, tosend);
+ sendRequestedMedia(peer_id, tosend);
// Now the client should know about everything
- // (definitions and textures)
+ // (definitions and files)
getClient(peer_id)->definitions_sent = true;
}
else if(command == TOSERVER_INTERACT)
}
}
-void Server::PrepareTextures()
+void Server::fillMediaCache()
{
DSTACK(__FUNCTION_NAME);
- infostream<<"Server: Calculating texture checksums"<<std::endl;
+ infostream<<"Server: Calculating file checksums"<<std::endl;
for(core::list<ModSpec>::Iterator i = m_mods.begin();
i != m_mods.end(); i++){
const ModSpec &mod = *i;
- std::string texturepath = mod.path + DIR_DELIM + "textures";
- std::vector<fs::DirListNode> dirlist = fs::GetDirListing(texturepath);
+ std::string filepath = mod.path + DIR_DELIM + "textures";
+ std::vector<fs::DirListNode> dirlist = fs::GetDirListing(filepath);
for(u32 j=0; j<dirlist.size(); j++){
if(dirlist[j].dir) // Ignode dirs
continue;
std::string tname = dirlist[j].name;
- // if name contains illegal characters, ignore the texture
+ // if name contains illegal characters, ignore the file
if(!string_allowed(tname, TEXTURENAME_ALLOWED_CHARS)){
- errorstream<<"Server: ignoring illegal texture name: \""
+ errorstream<<"Server: ignoring illegal file name: \""
<<tname<<"\""<<std::endl;
continue;
}
- std::string tpath = texturepath + DIR_DELIM + tname;
+ std::string tpath = filepath + DIR_DELIM + tname;
// Read data
std::ifstream fis(tpath.c_str(), std::ios_base::binary);
if(fis.good() == false){
- errorstream<<"Server::PrepareTextures(): Could not open \""
+ errorstream<<"Server::fillMediaCache(): Could not open \""
<<tname<<"\" for reading"<<std::endl;
continue;
}
}
}
if(bad){
- errorstream<<"Server::PrepareTextures(): Failed to read \""
+ errorstream<<"Server::fillMediaCache(): Failed to read \""
<<tname<<"\""<<std::endl;
continue;
}
if(tmp_os.str().length() == 0){
- errorstream<<"Server::PrepareTextures(): Empty file \""
+ errorstream<<"Server::fillMediaCache(): Empty file \""
<<tpath<<"\""<<std::endl;
continue;
}
free(digest);
// Put in list
- this->m_Textures[tname] = TextureInformation(tpath,digest_string);
+ this->m_media[tname] = MediaInfo(tpath,digest_string);
verbosestream<<"Server: sha1 for "<<tname<<"\tis "<<std::endl;
}
}
}
-struct SendableTextureAnnouncement
- {
- std::string name;
- std::string sha1_digest;
+struct SendableMediaAnnouncement
+{
+ std::string name;
+ std::string sha1_digest;
- SendableTextureAnnouncement(const std::string name_="",
- const std::string sha1_digest_=""):
- name(name_),
- sha1_digest(sha1_digest_)
- {
- }
- };
+ SendableMediaAnnouncement(const std::string name_="",
+ const std::string sha1_digest_=""):
+ name(name_),
+ sha1_digest(sha1_digest_)
+ {}
+};
-void Server::SendTextureAnnouncement(u16 peer_id){
+void Server::sendMediaAnnouncement(u16 peer_id)
+{
DSTACK(__FUNCTION_NAME);
- verbosestream<<"Server: Announcing
textures to id("<<peer_id<<")"
+ verbosestream<<"Server: Announcing
files to id("<<peer_id<<")"
<<std::endl;
- core::list<SendableTextureAnnouncement> texture_announcements;
-
- for (std::map<std::string,TextureInformation>::iterator i = m_Textures.begin();i != m_Textures.end(); i++ ) {
+ core::list<SendableMediaAnnouncement> file_announcements;
+ for(std::map<std::string, MediaInfo>::iterator i = m_media.begin();
+ i != m_media.end(); i++){
// Put in list
- texture_announcements.push_back(
- SendableTextureAnnouncement(i->first, i->second.sha1_digest));
+ file_announcements.push_back(
+ SendableMediaAnnouncement(i->first, i->second.sha1_digest));
}
- //send announcements
+ // Make packet
+ std::ostringstream os(std::ios_base::binary);
/*
u16 command
- u32 number of textures
+ u32 number of files
for each texture {
u16 length of name
string name
- u16 length of digest string
+ u16 length of sha1_digest
string sha1_digest
}
*/
- std::ostringstream os(std::ios_base::binary);
-
- writeU16(os, TOCLIENT_ANNOUNCE_TEXTURES);
- writeU16(os, texture_announcements.size());
+
+ writeU16(os, TOCLIENT_ANNOUNCE_MEDIA);
+ writeU16(os, file_announcements.size());
- for(core::list<SendableTextureAnnouncement>::Iterator
- j = texture_announcements.begin();
- j != texture_announcements.end(); j++){
+ for(core::list<SendableMediaAnnouncement>::Iterator
+ j = file_announcements.begin();
+ j != file_announcements.end(); j++){
os<<serializeString(j->name);
os<<serializeString(j->sha1_digest);
}
}
-struct SendableTexture
+struct SendableMedia
{
std::string name;
std::string path;
std::string data;
- SendableTexture(const std::string &name_="", const std::string path_="",
+ SendableMedia(const std::string &name_="", const std::string path_="",
const std::string &data_=""):
name(name_),
path(path_),
{}
};
-void Server::SendTexturesRequested(u16 peer_id,core::list<TextureRequest> tosend) {
+void Server::sendRequestedMedia(u16 peer_id,
+ const core::list<MediaRequest> &tosend)
+{
DSTACK(__FUNCTION_NAME);
- verbosestream<<"Server::SendTexturesRequested(): "
- <<"Sending textures to client"<<std::endl;
+ verbosestream<<"Server::sendRequestedMedia(): "
+ <<"Sending files to client"<<std::endl;
- /* Read textures */
+ /* Read files */
// Put 5kB in one bunch (this is not accurate)
u32 bytes_per_bunch = 5000;
- core::array< core::list<SendableTexture> > texture_bunches;
- texture_bunches.push_back(core::list<SendableTexture>());
+ core::array< core::list<SendableMedia> > file_bunches;
+ file_bunches.push_back(core::list<SendableMedia>());
- u32 texture_size_bunch_total = 0;
+ u32 file_size_bunch_total = 0;
- for(core::list<TextureRequest>::Iterator i = tosend.begin(); i != tosend.end(); i++) {
- if(m_Textures.find(i->name) == m_Textures.end()){
- errorstream<<"Server::SendTexturesRequested(): Client asked for "
- <<"unknown texture \""<<(i->name)<<"\""<<std::endl;
+ for(core::list<MediaRequest>::ConstIterator i = tosend.begin();
+ i != tosend.end(); i++)
+ {
+ if(m_media.find(i->name) == m_media.end()){
+ errorstream<<"Server::sendRequestedMedia(): Client asked for "
+ <<"unknown file \""<<(i->name)<<"\""<<std::endl;
continue;
}
//TODO get path + name
- std::string tpath = m_Textures[(*i).name].path;
+ std::string tpath = m_media[(*i).name].path;
// Read data
std::ifstream fis(tpath.c_str(), std::ios_base::binary);
if(fis.good() == false){
- errorstream<<"Server::SendTexturesRequested(): Could not open \""
+ errorstream<<"Server::sendRequestedMedia(): Could not open \""
<<tpath<<"\" for reading"<<std::endl;
continue;
}
fis.read(buf, 1024);
std::streamsize len = fis.gcount();
tmp_os.write(buf, len);
- texture_size_bunch_total += len;
+ file_size_bunch_total += len;
if(fis.eof())
break;
if(!fis.good()){
}
}
if(bad){
- errorstream<<"Server::SendTexturesRequested(): Failed to read \""
+ errorstream<<"Server::sendRequestedMedia(): Failed to read \""
<<(*i).name<<"\""<<std::endl;
continue;
}
- /*infostream<<"Server::SendTexturesRequested(): Loaded \""
+ /*infostream<<"Server::sendRequestedMedia(): Loaded \""
<<tname<<"\""<<std::endl;*/
// Put in list
- texture_bunches[texture_bunches.size()-1].push_back(
- SendableTexture((*i).name, tpath, tmp_os.str()));
+ file_bunches[file_bunches.size()-1].push_back(
+ SendableMedia((*i).name, tpath, tmp_os.str()));
// Start next bunch if got enough data
- if(texture_size_bunch_total >= bytes_per_bunch){
- texture_bunches.push_back(core::list<SendableTexture>());
- texture_size_bunch_total = 0;
+ if(file_size_bunch_total >= bytes_per_bunch){
+ file_bunches.push_back(core::list<SendableMedia>());
+ file_size_bunch_total = 0;
}
}
/* Create and send packets */
- u32 num_bunches = texture_bunches.size();
- for(u32 i=0; i<num_bunches; i++)
- {
- /*
- u16 command
- u16 total number of texture bunches
- u16 index of this bunch
- u32 number of textures in this bunch
- for each texture {
- u16 length of name
- string name
- u32 length of data
- data
- }
- */
- std::ostringstream os(std::ios_base::binary);
-
- writeU16(os, TOCLIENT_TEXTURES);
- writeU16(os, num_bunches);
- writeU16(os, i);
- writeU32(os, texture_bunches[i].size());
+ u32 num_bunches = file_bunches.size();
+ for(u32 i=0; i<num_bunches; i++)
+ {
+ std::ostringstream os(std::ios_base::binary);
- for(core::list<SendableTexture>::Iterator
- j = texture_bunches[i].begin();
- j != texture_bunches[i].end(); j++){
- os<<serializeString(j->name);
- os<<serializeLongString(j->data);
+ /*
+ u16 command
+ u16 total number of texture bunches
+ u16 index of this bunch
+ u32 number of files in this bunch
+ for each file {
+ u16 length of name
+ string name
+ u32 length of data
+ data
}
+ */
- // Make data buffer
- std::string s = os.str();
- verbosestream<<"Server::SendTexturesRequested(): bunch "
- <<i<<"/"<<num_bunches
- <<" textures="<<texture_bunches[i].size()
- <<" size=" <<s.size()<<std::endl;
- SharedBuffer<u8> data((u8*)s.c_str(), s.size());
- // Send as reliable
- m_con.Send(peer_id, 0, data, true);
- }
+ writeU16(os, TOCLIENT_MEDIA);
+ writeU16(os, num_bunches);
+ writeU16(os, i);
+ writeU32(os, file_bunches[i].size());
+ for(core::list<SendableMedia>::Iterator
+ j = file_bunches[i].begin();
+ j != file_bunches[i].end(); j++){
+ os<<serializeString(j->name);
+ os<<serializeLongString(j->data);
+ }
+ // Make data buffer
+ std::string s = os.str();
+ verbosestream<<"Server::sendRequestedMedia(): bunch "
+ <<i<<"/"<<num_bunches
+ <<" files="<<file_bunches[i].size()
+ <<" size=" <<s.size()<<std::endl;
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ m_con.Send(peer_id, 0, data, true);
+ }
}
/*
u16 peer_id;
};
-struct TextureRequest
+struct MediaRequest
{
std::string name;
- TextureRequest(const std::string &name_=""):
+ MediaRequest(const std::string &name_=""):
name(name_)
{}
};
-struct TextureInformation
+struct MediaInfo
{
std::string path;
std::string sha1_digest;
- TextureInformation(const std::string path_="",
+ MediaInfo(const std::string path_="",
const std::string sha1_digest_=""):
path(path_),
sha1_digest(sha1_digest_)
// Sends blocks to clients (locks env and con on its own)
void SendBlocks(float dtime);
- void PrepareTextures();
-
- void SendTextureAnnouncement(u16 peer_id);
-
- void SendTexturesRequested(u16 peer_id,core::list<TextureRequest> tosend);
+ void fillMediaCache();
+ void sendMediaAnnouncement(u16 peer_id);
+ void sendRequestedMedia(u16 peer_id,
+ const core::list<MediaRequest> &tosend);
/*
Something random
friend class EmergeThread;
friend class RemoteClient;
- std::map<std::string,TextureInformation> m_Textures;
+ std::map<std::string,MediaInfo> m_media;
/*
Sounds
projects / zefram / minetest / minetest_engine.git / commitdiff