X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.cpp;h=2bbc0ebbf9f76d9ab0750afb7d24f2caf5920a1b;hb=e80f695bb96923a718890ccfec37f39e12d8d235;hp=631e9db6505bfa2176c460b071238f18bea74e1d;hpb=8f7785771b9e02b1a1daf7a252550d78ea93053d;p=minetest.git diff --git a/src/mapblock.cpp b/src/mapblock.cpp index 631e9db65..2bbc0ebbf 100644 --- a/src/mapblock.cpp +++ b/src/mapblock.cpp @@ -31,8 +31,9 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "content_nodemeta.h" // For legacy deserialization #include "serialization.h" #ifndef SERVER -#include "mapblock_mesh.h" +#include "client/mapblock_mesh.h" #endif +#include "porting.h" #include "util/string.h" #include "util/serialize.h" #include "util/basic_macros.h" @@ -71,7 +72,7 @@ MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy): m_pos_relative(pos * MAP_BLOCKSIZE), m_gamedef(gamedef) { - if(dummy == false) + if (!dummy) reallocate(); } @@ -89,24 +90,22 @@ MapBlock::~MapBlock() bool MapBlock::isValidPositionParent(v3s16 p) { - if(isValidPosition(p)) - { + if (isValidPosition(p)) { return true; } - else{ - return m_parent->isValidPosition(getPosRelative() + p); - } + + return m_parent->isValidPosition(getPosRelative() + p); } MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position) { - if (isValidPosition(p) == false) - return m_parent->getNodeNoEx(getPosRelative() + p, is_valid_position); + if (!isValidPosition(p)) + return m_parent->getNode(getPosRelative() + p, is_valid_position); if (!data) { if (is_valid_position) *is_valid_position = false; - return MapNode(CONTENT_IGNORE); + return {CONTENT_IGNORE}; } if (is_valid_position) *is_valid_position = true; @@ -134,200 +133,6 @@ std::string MapBlock::getModifiedReasonString() return reason; } -/* - Propagates sunlight down through the block. - Doesn't modify nodes that are not affected by sunlight. - - Returns false if sunlight at bottom block is invalid. - Returns true if sunlight at bottom block is valid. - Returns true if bottom block doesn't exist. - - If there is a block above, continues from it. - If there is no block above, assumes there is sunlight, unless - is_underground is set or highest node is water. - - All sunlighted nodes are added to light_sources. - - if remove_light==true, sets non-sunlighted nodes black. - - if black_air_left!=NULL, it is set to true if non-sunlighted - air is left in block. -*/ -bool MapBlock::propagateSunlight(std::set & light_sources, - bool remove_light, bool *black_air_left) -{ - INodeDefManager *nodemgr = m_gamedef->ndef(); - - // Whether the sunlight at the top of the bottom block is valid - bool block_below_is_valid = true; - - v3s16 pos_relative = getPosRelative(); - - for(s16 x=0; xndef()) != LIGHT_SUN) - { - no_sunlight = true; - } - } - else - { - //no_top_block = true; - - // NOTE: This makes over-ground roofed places sunlighted - // Assume sunlight, unless is_underground==true - if(is_underground) - { - no_sunlight = true; - } - else - { - MapNode n = getNodeNoEx(v3s16(x, MAP_BLOCKSIZE-1, z)); - if(m_gamedef->ndef()->get(n).sunlight_propagates == false) - { - no_sunlight = true; - } - } - // NOTE: As of now, this just would make everything dark. - // No sunlight here - //no_sunlight = true; - } -#endif -#if 0 // Doesn't work; nothing gets light. - bool no_sunlight = true; - bool no_top_block = false; - // Check if node above block has sunlight - try{ - MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z)); - if(n.getLight(LIGHTBANK_DAY) == LIGHT_SUN) - { - no_sunlight = false; - } - } - catch(InvalidPositionException &e) - { - no_top_block = true; - } -#endif - - /*std::cout<<"("<ndef(); + const NodeDefManager *nodemgr = m_gamedef->ndef(); // Running this function un-expires m_day_night_differs m_day_night_differs_expired = false; @@ -361,17 +166,24 @@ void MapBlock::actuallyUpdateDayNightDiff() return; } - bool differs; + bool differs = false; /* Check if any lighting value differs */ + + MapNode previous_n(CONTENT_IGNORE); for (u32 i = 0; i < nodecount; i++) { - MapNode &n = data[i]; + MapNode n = data[i]; + + // If node is identical to previous node, don't verify if it differs + if (n == previous_n) + continue; differs = !n.isLightDayNightEq(nodemgr); if (differs) break; + previous_n = n; } /* @@ -406,66 +218,43 @@ void MapBlock::expireDayNightDiff() m_day_night_differs_expired = true; } -s16 MapBlock::getGroundLevel(v2s16 p2d) -{ - if(isDummy()) - return -3; - try - { - s16 y = MAP_BLOCKSIZE-1; - for(; y>=0; y--) - { - MapNode n = getNodeRef(p2d.X, y, p2d.Y); - if(m_gamedef->ndef()->get(n).walkable) - { - if(y == MAP_BLOCKSIZE-1) - return -2; - else - return y; - } - } - return -1; - } - catch(InvalidPositionException &e) - { - return -3; - } -} - /* Serialization */ + // List relevant id-name pairs for ids in the block using nodedef -// Renumbers the content IDs (starting at 0 and incrementing -// use static memory requires about 65535 * sizeof(int) ram in order to be -// sure we can handle all content ids. But it's absolutely worth it as it's -// a speedup of 4 for one of the major time consuming functions on storing -// mapblocks. -static content_t getBlockNodeIdMapping_mapping[USHRT_MAX + 1]; +// Renumbers the content IDs (starting at 0 and incrementing) static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes, - INodeDefManager *nodedef) + const NodeDefManager *nodedef) { - memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t)); - - std::set unknown_contents; + // The static memory requires about 65535 * sizeof(int) RAM in order to be + // sure we can handle all content ids. But it's absolutely worth it as it's + // a speedup of 4 for one of the major time consuming functions on storing + // mapblocks. + thread_local std::unique_ptr mapping; + static_assert(sizeof(content_t) == 2, "content_t must be 16-bit"); + if (!mapping) + mapping = std::make_unique(USHRT_MAX + 1); + + memset(mapping.get(), 0xFF, (USHRT_MAX + 1) * sizeof(content_t)); + + std::unordered_set unknown_contents; content_t id_counter = 0; for (u32 i = 0; i < MapBlock::nodecount; i++) { content_t global_id = nodes[i].getContent(); content_t id = CONTENT_IGNORE; // Try to find an existing mapping - if (getBlockNodeIdMapping_mapping[global_id] != 0xFFFF) { - id = getBlockNodeIdMapping_mapping[global_id]; - } - else - { + if (mapping[global_id] != 0xFFFF) { + id = mapping[global_id]; + } else { // We have to assign a new mapping id = id_counter++; - getBlockNodeIdMapping_mapping[global_id] = id; + mapping[global_id] = id; const ContentFeatures &f = nodedef->get(global_id); const std::string &name = f.name; - if(name == "") + if (name.empty()) unknown_contents.insert(global_id); else nimap->set(id, name); @@ -474,62 +263,78 @@ static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes, // Update the MapNode nodes[i].setContent(id); } - for(std::set::const_iterator - i = unknown_contents.begin(); - i != unknown_contents.end(); ++i){ - errorstream<<"getBlockNodeIdMapping(): IGNORING ERROR: " - <<"Name for node id "<<(*i)<<" not known"<ndef(); + const NodeDefManager *nodedef = gamedef->ndef(); // This means the block contains incorrect ids, and we contain // the information to convert those to names. // nodedef contains information to convert our names to globally // correct ids. - std::set unnamed_contents; - std::set unallocatable_contents; + std::unordered_set unnamed_contents; + std::unordered_set unallocatable_contents; + + bool previous_exists = false; + content_t previous_local_id = CONTENT_IGNORE; + content_t previous_global_id = CONTENT_IGNORE; + for (u32 i = 0; i < MapBlock::nodecount; i++) { content_t local_id = nodes[i].getContent(); + // If previous node local_id was found and same than before, don't lookup maps + // apply directly previous resolved id + // This permits to massively improve loading performance when nodes are similar + // example: default:air, default:stone are massively present + if (previous_exists && local_id == previous_local_id) { + nodes[i].setContent(previous_global_id); + continue; + } + std::string name; - bool found = nimap->getName(local_id, name); - if(!found){ + if (!nimap->getName(local_id, name)) { unnamed_contents.insert(local_id); + previous_exists = false; continue; } + content_t global_id; - found = nodedef->getId(name, global_id); - if(!found){ + if (!nodedef->getId(name, global_id)) { global_id = gamedef->allocateUnknownNodeId(name); - if(global_id == CONTENT_IGNORE){ + if (global_id == CONTENT_IGNORE) { unallocatable_contents.insert(name); + previous_exists = false; continue; } } nodes[i].setContent(global_id); + + // Save previous node local_id & global_id result + previous_local_id = local_id; + previous_global_id = global_id; + previous_exists = true; } - for(std::set::const_iterator - i = unnamed_contents.begin(); - i != unnamed_contents.end(); ++i){ - errorstream<<"correctBlockNodeIds(): IGNORING ERROR: " - <<"Block contains id "<<(*i) - <<" with no name mapping"<::const_iterator - i = unallocatable_contents.begin(); - i != unallocatable_contents.end(); ++i){ - errorstream<<"correctBlockNodeIds(): IGNORING ERROR: " - <<"Could not allocate global id for node name \"" - <<(*i)<<"\""<= 29 ? os_raw : os_compressed; + // First byte u8 flags = 0; if(is_underground) flags |= 0x01; if(getDayNightDiff()) flags |= 0x02; - if(m_generated == false) + if (!m_generated) flags |= 0x08; writeU8(os, flags); if (version >= 27) { @@ -556,37 +364,52 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk) Bulk node data */ NameIdMapping nimap; - if(disk) + SharedBuffer buf; + const u8 content_width = 2; + const u8 params_width = 2; + if(disk) { MapNode *tmp_nodes = new MapNode[nodecount]; - for(u32 i=0; indef()); - u8 content_width = 2; - u8 params_width = 2; - writeU8(os, content_width); - writeU8(os, params_width); - MapNode::serializeBulk(os, version, tmp_nodes, nodecount, - content_width, params_width, true); + buf = MapNode::serializeBulk(version, tmp_nodes, nodecount, + content_width, params_width); delete[] tmp_nodes; + + // write timestamp and node/id mapping first + if (version >= 29) { + writeU32(os, getTimestamp()); + + nimap.serialize(os); + } } else { - u8 content_width = 2; - u8 params_width = 2; - writeU8(os, content_width); - writeU8(os, params_width); - MapNode::serializeBulk(os, version, data, nodecount, - content_width, params_width, true); + buf = MapNode::serializeBulk(version, data, nodecount, + content_width, params_width); + } + + writeU8(os, content_width); + writeU8(os, params_width); + if (version >= 29) { + os.write(reinterpret_cast(*buf), buf.getSize()); + } else { + // prior to 29 node data was compressed individually + compress(buf, os, version, compression_level); } /* Node metadata */ - std::ostringstream oss(std::ios_base::binary); - m_node_metadata.serialize(oss, version, disk); - compressZlib(oss.str(), os); + if (version >= 29) { + m_node_metadata.serialize(os, version, disk); + } else { + // use os_raw from above to avoid allocating another stream object + m_node_metadata.serialize(os_raw, version, disk); + // prior to 29 node data was compressed individually + compress(os_raw.str(), os, version, compression_level); + } /* Data that goes to disk, but not the network @@ -601,17 +424,24 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk) // Static objects m_static_objects.serialize(os); - // Timestamp - writeU32(os, getTimestamp()); + if(version < 29){ + // Timestamp + writeU32(os, getTimestamp()); - // Write block-specific node definition id mapping - nimap.serialize(os); + // Write block-specific node definition id mapping + nimap.serialize(os); + } if(version >= 25){ // Node timers m_node_timers.serialize(os, version); } } + + if (version >= 29) { + // now compress the whole thing + compress(os_raw.str(), os_compressed, version, compression_level); + } } void MapBlock::serializeNetworkSpecific(std::ostream &os) @@ -620,12 +450,10 @@ void MapBlock::serializeNetworkSpecific(std::ostream &os) throw SerializationError("ERROR: Not writing dummy block."); } - writeU8(os, 1); // version - writeF1000(os, 0); // deprecated heat - writeF1000(os, 0); // deprecated humidity + writeU8(os, 2); // version } -void MapBlock::deSerialize(std::istream &is, u8 version, bool disk) +void MapBlock::deSerialize(std::istream &in_compressed, u8 version, bool disk) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapBlock format not supported"); @@ -636,22 +464,39 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk) if(version <= 21) { - deSerialize_pre22(is, version, disk); + deSerialize_pre22(in_compressed, version, disk); return; } + // Decompress the whole block (version >= 29) + std::stringstream in_raw(std::ios_base::binary | std::ios_base::in | std::ios_base::out); + if (version >= 29) + decompress(in_compressed, in_raw, version); + std::istream &is = version >= 29 ? in_raw : in_compressed; + u8 flags = readU8(is); - is_underground = (flags & 0x01) ? true : false; - m_day_night_differs = (flags & 0x02) ? true : false; + is_underground = (flags & 0x01) != 0; + m_day_night_differs = (flags & 0x02) != 0; if (version < 27) m_lighting_complete = 0xFFFF; else m_lighting_complete = readU16(is); - m_generated = (flags & 0x08) ? false : true; + m_generated = (flags & 0x08) == 0; + + NameIdMapping nimap; + if (disk && version >= 29) { + // Timestamp + TRACESTREAM(<<"MapBlock::deSerialize "<= 29) { + MapNode::deSerializeBulk(is, version, data, nodecount, + content_width, params_width); + } else { + // use in_raw from above to avoid allocating another stream object + decompress(is, in_raw, version); + MapNode::deSerializeBulk(in_raw, version, data, nodecount, + content_width, params_width); + } /* NodeMetadata */ TRACESTREAM(<<"MapBlock::deSerialize "<= 23) - m_node_metadata.deSerialize(iss, m_gamedef->idef()); - else - content_nodemeta_deserialize_legacy(iss, - &m_node_metadata, &m_node_timers, - m_gamedef->idef()); - } catch(SerializationError &e) { - warningstream<<"MapBlock::deSerialize(): Ignoring an error" - <<" while deserializing node metadata at (" - <= 29) { + m_node_metadata.deSerialize(is, m_gamedef->idef()); + } else { + try { + // reuse in_raw + in_raw.str(""); + in_raw.clear(); + decompress(is, in_raw, version); + if (version >= 23) + m_node_metadata.deSerialize(in_raw, m_gamedef->idef()); + else + content_nodemeta_deserialize_legacy(in_raw, + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerialize(): Ignoring an error" + <<" while deserializing node metadata at (" + <= 25){ @@ -733,16 +596,12 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk) void MapBlock::deSerializeNetworkSpecific(std::istream &is) { try { - int version = readU8(is); - //if(version != 1) - // throw SerializationError("unsupported MapBlock version"); - if(version >= 1) { - readF1000(is); // deprecated heat - readF1000(is); // deprecated humidity - } - } - catch(SerializationError &e) - { + readU8(is); + //const u8 version = readU8(is); + //if (version != 1) + //throw SerializationError("unsupported MapBlock version"); + + } catch(SerializationError &e) { warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error" <<": "<= 18) - m_generated = (flags & 0x08) ? false : true; + m_generated = (flags & 0x08) == 0; // Uncompress data std::ostringstream os(std::ios_base::binary); @@ -848,13 +707,13 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk) // Ignore errors try { if (version <= 15) { - std::string data = deSerializeString(is); + std::string data = deSerializeString16(is); std::istringstream iss(data, std::ios_base::binary); content_nodemeta_deserialize_legacy(iss, &m_node_metadata, &m_node_timers, m_gamedef->idef()); } else { - //std::string data = deSerializeLongString(is); + //std::string data = deSerializeString32(is); std::ostringstream oss(std::ios_base::binary); decompressZlib(is, oss); std::istringstream iss(oss.str(), std::ios_base::binary); @@ -896,10 +755,10 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk) // Timestamp if (version >= 17) { - setTimestamp(readU32(is)); + setTimestampNoChangedFlag(readU32(is)); m_disk_timestamp = m_timestamp; } else { - setTimestamp(BLOCK_TIMESTAMP_UNDEFINED); + setTimestampNoChangedFlag(BLOCK_TIMESTAMP_UNDEFINED); } // Dynamically re-set ids based on node names @@ -917,7 +776,7 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk) // Legacy data changes // This code has to convert from pre-22 to post-22 format. - INodeDefManager *nodedef = m_gamedef->ndef(); + const NodeDefManager *nodedef = m_gamedef->ndef(); for(u32 i=0; iget(data[i].getContent()); @@ -971,8 +830,8 @@ std::string analyze_block(MapBlock *block) std::ostringstream desc; v3s16 p = block->getPos(); - char spos[20]; - snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z); + char spos[25]; + porting::mt_snprintf(spos, sizeof(spos), "(%2d,%2d,%2d), ", p.X, p.Y, p.Z); desc<getModified())