X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.cpp;h=0ca71e643d83f11a8413636eabeeff6d90102916;hb=49728d0b01e67cbb69aec394d7af5b81e86e5ebc;hp=4cc0abc8176104c5a5a922205d6067de223e7df2;hpb=ca217d041639883ffcc1c7f7856502efca1b90a4;p=minetest.git diff --git a/src/mapblock.cpp b/src/mapblock.cpp index 4cc0abc81..0ca71e643 100644 --- a/src/mapblock.cpp +++ b/src/mapblock.cpp @@ -31,12 +31,36 @@ 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" + +static const char *modified_reason_strings[] = { + "initial", + "reallocate", + "setIsUnderground", + "setLightingExpired", + "setGenerated", + "setNode", + "setNodeNoCheck", + "setTimestamp", + "NodeMetaRef::reportMetadataChange", + "clearAllObjects", + "Timestamp expired (step)", + "addActiveObjectRaw", + "removeRemovedObjects/remove", + "removeRemovedObjects/deactivate", + "Stored list cleared in activateObjects due to overflow", + "deactivateFarObjects: Static data moved in", + "deactivateFarObjects: Static data moved out", + "deactivateFarObjects: Static data changed considerably", + "finishBlockMake: expireDayNightDiff", + "unknown", +}; -#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")" /* MapBlock @@ -45,265 +69,68 @@ with this program; if not, write to the Free Software Foundation, Inc., MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy): m_parent(parent), m_pos(pos), - m_gamedef(gamedef), - m_modified(MOD_STATE_WRITE_NEEDED), - m_modified_reason("initial"), - m_modified_reason_too_long(false), - is_underground(false), - m_lighting_expired(true), - m_day_night_differs(false), - m_day_night_differs_expired(true), - m_generated(false), - m_timestamp(BLOCK_TIMESTAMP_UNDEFINED), - m_disk_timestamp(BLOCK_TIMESTAMP_UNDEFINED), - m_usage_timer(0), - m_refcount(0) + m_pos_relative(pos * MAP_BLOCKSIZE), + m_gamedef(gamedef) { - data = NULL; - if(dummy == false) + if (!dummy) reallocate(); - -#ifndef SERVER - mesh = NULL; -#endif } MapBlock::~MapBlock() { #ifndef SERVER { - //JMutexAutoLock lock(mesh_mutex); - - if(mesh) - { - delete mesh; - mesh = NULL; - } + delete mesh; + mesh = nullptr; } #endif - if(data) - delete[] data; + delete[] data; } 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 == NULL) { + 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; - return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X]; + return data[p.Z * zstride + p.Y * ystride + p.X]; } -/* - 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) +std::string MapBlock::getModifiedReasonString() { - 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<<"("< 2) + reason.resize(reason.length() - 2); + + return reason; } @@ -329,12 +156,12 @@ void MapBlock::copyFrom(VoxelManipulator &dst) void MapBlock::actuallyUpdateDayNightDiff() { - INodeDefManager *nodemgr = m_gamedef->ndef(); + const NodeDefManager *nodemgr = m_gamedef->ndef(); + // Running this function un-expires m_day_night_differs m_day_night_differs_expired = false; - if(data == NULL) - { + if (!data) { m_day_night_differs = false; return; } @@ -344,33 +171,35 @@ void MapBlock::actuallyUpdateDayNightDiff() /* Check if any lighting value differs */ - for(u32 i=0; indef(); - - if(data == NULL){ + if (!data) { m_day_night_differs = false; m_day_night_differs_expired = false; return; @@ -401,12 +228,11 @@ s16 MapBlock::getGroundLevel(v2s16 p2d) for(; y>=0; y--) { MapNode n = getNodeRef(p2d.X, y, p2d.Y); - if(m_gamedef->ndef()->get(n).walkable) - { + if (m_gamedef->ndef()->get(n).walkable) { if(y == MAP_BLOCKSIZE-1) return -2; - else - return y; + + return y; } } return -1; @@ -426,16 +252,15 @@ s16 MapBlock::getGroundLevel(v2s16 p2d) // 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]; +static content_t getBlockNodeIdMapping_mapping[USHRT_MAX + 1]; static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes, - INodeDefManager *nodedef) + const NodeDefManager *nodedef) { - memset(getBlockNodeIdMapping_mapping, 0xFF, USHRT_MAX * sizeof(content_t)); + memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t)); std::set unknown_contents; content_t id_counter = 0; - for(u32 i=0; iget(global_id); const std::string &name = f.name; - if(name == "") + if (name.empty()) unknown_contents.insert(global_id); else nimap->set(id, name); @@ -460,11 +285,9 @@ 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; - for(u32 i=0; i 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)<<"\""<= 27) { + writeU16(os, m_lighting_complete); + } /* Bulk node data */ NameIdMapping nimap; - u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; if(disk) { MapNode *tmp_nodes = new MapNode[nodecount]; @@ -561,7 +394,7 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk) writeU8(os, content_width); writeU8(os, params_width); MapNode::serializeBulk(os, version, tmp_nodes, nodecount, - content_width, params_width, true); + content_width, params_width, compression_level); delete[] tmp_nodes; } else @@ -571,15 +404,15 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk) writeU8(os, content_width); writeU8(os, params_width); MapNode::serializeBulk(os, version, data, nodecount, - content_width, params_width, true); + content_width, params_width, compression_level); } /* Node metadata */ std::ostringstream oss(std::ios_base::binary); - m_node_metadata.serialize(oss); - compressZlib(oss.str(), os); + m_node_metadata.serialize(oss, version, disk); + compressZlib(oss.str(), os, compression_level); /* Data that goes to disk, but not the network @@ -607,19 +440,13 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk) } } -void MapBlock::serializeNetworkSpecific(std::ostream &os, u16 net_proto_version) +void MapBlock::serializeNetworkSpecific(std::ostream &os) { - if(data == NULL) - { + if (!data) { throw SerializationError("ERROR: Not writing dummy block."); } - if(net_proto_version >= 21){ - int version = 1; - writeU8(os, 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) @@ -638,17 +465,19 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk) } u8 flags = readU8(is); - is_underground = (flags & 0x01) ? true : false; - m_day_night_differs = (flags & 0x02) ? true : false; - m_lighting_expired = (flags & 0x04) ? true : false; - m_generated = (flags & 0x08) ? false : true; + 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) == 0; /* Bulk node data */ TRACESTREAM(<<"MapBlock::deSerialize "<= 23) - m_node_metadata.deSerialize(iss, m_gamedef); + if (version >= 23) + m_node_metadata.deSerialize(iss, m_gamedef->idef()); else content_nodemeta_deserialize_legacy(iss, - &m_node_metadata, &m_node_timers, - m_gamedef); - } - catch(SerializationError &e) - { - errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error" + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerialize(): Ignoring an error" <<" while deserializing node metadata at (" <= 1) { - readF1000(is); // deprecated heat - readF1000(is); // deprecated humidity - } - } - catch(SerializationError &e) - { - errorstream<<"WARNING: MapBlock::deSerializeNetworkSpecific(): Ignoring an error" + readU8(is); + //const u8 version = readU8(is); + //if (version != 1) + //throw SerializationError("unsupported MapBlock version"); + + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error" <<": "< databuf_nodelist(nodecount * ser_length); // These have no compression - if(version <= 3 || version == 5 || version == 6) - { + if (version <= 3 || version == 5 || version == 6) { char tmp; is.read(&tmp, 1); - if(is.gcount() != 1) - throw SerializationError - ("MapBlock::deSerialize: no enough input data"); + if (is.gcount() != 1) + throw SerializationError(std::string(FUNCTION_NAME) + + ": not enough input data"); is_underground = tmp; - is.read((char*)*databuf_nodelist, nodecount * ser_length); - if((u32)is.gcount() != nodecount * ser_length) - throw SerializationError - ("MapBlock::deSerialize: no enough input data"); - } - else if(version <= 10) - { + is.read((char *)*databuf_nodelist, nodecount * ser_length); + if ((u32)is.gcount() != nodecount * ser_length) + throw SerializationError(std::string(FUNCTION_NAME) + + ": not enough input data"); + } else if (version <= 10) { u8 t8; - is.read((char*)&t8, 1); + is.read((char *)&t8, 1); is_underground = t8; { @@ -788,11 +606,10 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk) std::ostringstream os(std::ios_base::binary); decompress(is, os, version); std::string s = os.str(); - if(s.size() != nodecount) - throw SerializationError - ("MapBlock::deSerialize: invalid format"); - for(u32 i=0; i= 10) - { + if (version >= 10) { // Uncompress and set param2 data std::ostringstream os(std::ios_base::binary); decompress(is, os, version); std::string s = os.str(); - if(s.size() != nodecount) - throw SerializationError - ("MapBlock::deSerialize: invalid format"); - for(u32 i=0; i= 18) - m_generated = (flags & 0x08) ? false : true; + m_generated = (flags & 0x08) == 0; // Uncompress data std::ostringstream os(std::ios_base::binary); decompress(is, os, version); std::string s = os.str(); - if(s.size() != nodecount*3) - throw SerializationError - ("MapBlock::deSerialize: decompress resulted in size" - " other than nodecount*3"); + if (s.size() != nodecount * 3) + throw SerializationError(std::string(FUNCTION_NAME) + + ": decompress resulted in size other than nodecount*3"); // deserialize nodes from buffer - for(u32 i=0; i= 14) - { + if (version >= 14) { // Ignore errors - try{ - if(version <= 15) - { - std::string data = deSerializeString(is); + try { + if (version <= 15) { + 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); - } - else - { - //std::string data = deSerializeLongString(is); + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); + } else { + //std::string data = deSerializeString32(is); std::ostringstream oss(std::ios_base::binary); decompressZlib(is, oss); std::istringstream iss(oss.str(), std::ios_base::binary); content_nodemeta_deserialize_legacy(iss, - &m_node_metadata, &m_node_timers, - m_gamedef); + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); } - } - catch(SerializationError &e) - { - errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error" + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerialize(): Ignoring an error" <<" while deserializing node metadata"<= 9){ + if (version >= 9) { u16 count = readU16(is); // Not supported and length not known if count is not 0 if(count != 0){ - errorstream<<"WARNING: MapBlock::deSerialize_pre22(): " + warningstream<<"MapBlock::deSerialize_pre22(): " <<"Ignoring stuff coming at and after MBOs"<= 15) + if (version >= 15) m_static_objects.deSerialize(is); // Timestamp - if(version >= 17){ - setTimestamp(readU32(is)); + if (version >= 17) { + 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 NameIdMapping nimap; // If supported, read node definition id mapping - if(version >= 21){ + if (version >= 21) { nimap.deSerialize(is); // Else set the legacy mapping } else { @@ -937,7 +737,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()); @@ -991,8 +791,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()) @@ -1020,10 +820,7 @@ std::string analyze_block(MapBlock *block) else desc<<"is_ug [ ], "; - if(block->getLightingExpired()) - desc<<"lighting_exp [X], "; - else - desc<<"lighting_exp [ ], "; + desc<<"lighting_complete: "<getLightingComplete()<<", "; if(block->isDummy()) {