/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "mapblock.h"
+
+#include <sstream>
#include "map.h"
-// For g_materials
-#include "main.h"
#include "light.h"
-#include <sstream>
+#include "nodedef.h"
+#include "nodemetadata.h"
+#include "gamedef.h"
+#include "log.h"
+#include "nameidmapping.h"
+#include "content_mapnode.h" // For legacy name-id mapping
+#include "content_nodemeta.h" // For legacy deserialization
+#include "serialization.h"
+#ifndef SERVER
+#include "mapblock_mesh.h"
+#endif
+#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",
+};
/*
MapBlock
*/
-bool MapBlock::isValidPositionParent(v3s16 p)
+MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
+ m_parent(parent),
+ m_pos(pos),
+ m_pos_relative(pos * MAP_BLOCKSIZE),
+ m_gamedef(gamedef)
{
- if(isValidPosition(p))
- {
- return true;
- }
- else{
- return m_parent->isValidPosition(getPosRelative() + p);
- }
+ if (!dummy)
+ reallocate();
}
-MapNode MapBlock::getNodeParent(v3s16 p)
+MapBlock::~MapBlock()
{
- if(isValidPosition(p) == false)
+#ifndef SERVER
{
- return m_parent->getNode(getPosRelative() + p);
- }
- else
- {
- if(data == NULL)
- throw InvalidPositionException();
- return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
+ delete mesh;
+ mesh = nullptr;
}
+#endif
+
+ delete[] data;
}
-void MapBlock::setNodeParent(v3s16 p, MapNode & n)
+bool MapBlock::isValidPositionParent(v3s16 p)
{
- if(isValidPosition(p) == false)
- {
- m_parent->setNode(getPosRelative() + p, n);
- }
- else
- {
- if(data == NULL)
- throw InvalidPositionException();
- data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X] = n;
+ if (isValidPosition(p)) {
+ return true;
}
+
+ return m_parent->isValidPosition(getPosRelative() + p);
}
-FastFace * MapBlock::makeFastFace(u8 material, u8 light, v3f p,
- v3f dir, v3f scale, v3f posRelative_f)
+MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position)
{
- FastFace *f = new FastFace;
-
- // Position is at the center of the cube.
- v3f pos = p * BS;
- posRelative_f *= BS;
-
- v3f vertex_pos[4];
- // If looking towards z+, this is the face that is behind
- // the center point, facing towards z+.
- vertex_pos[0] = v3f( BS/2,-BS/2,BS/2);
- vertex_pos[1] = v3f(-BS/2,-BS/2,BS/2);
- vertex_pos[2] = v3f(-BS/2, BS/2,BS/2);
- vertex_pos[3] = v3f( BS/2, BS/2,BS/2);
-
- /*
- TODO: Rotate it the right way (one side comes upside down)
- */
- core::CMatrix4<f32> m;
- m.buildRotateFromTo(v3f(0,0,1), dir);
-
- for(u16 i=0; i<4; i++){
- m.rotateVect(vertex_pos[i]);
- vertex_pos[i].X *= scale.X;
- vertex_pos[i].Y *= scale.Y;
- vertex_pos[i].Z *= scale.Z;
- vertex_pos[i] += pos + posRelative_f;
- }
-
- f32 abs_scale = 1.;
- if (scale.X < 0.999 || scale.X > 1.001) abs_scale = scale.X;
- else if(scale.Y < 0.999 || scale.Y > 1.001) abs_scale = scale.Y;
- else if(scale.Z < 0.999 || scale.Z > 1.001) abs_scale = scale.Z;
-
- v3f zerovector = v3f(0,0,0);
-
- u8 li = decode_light(light);
- //u8 li = 150;
-
- u8 alpha = 255;
-
- if(material == CONTENT_WATER || material == CONTENT_OCEAN)
- {
- alpha = 128;
- }
-
- video::SColor c = video::SColor(alpha,li,li,li);
-
- /*f->vertices[0] = video::S3DVertex(vertex_pos[0], zerovector, c,
- core::vector2d<f32>(0,1));
- f->vertices[1] = video::S3DVertex(vertex_pos[1], zerovector, c,
- core::vector2d<f32>(abs_scale,1));
- f->vertices[2] = video::S3DVertex(vertex_pos[2], zerovector, c,
- core::vector2d<f32>(abs_scale,0));
- f->vertices[3] = video::S3DVertex(vertex_pos[3], zerovector, c,
- core::vector2d<f32>(0,0));*/
- f->vertices[0] = video::S3DVertex(vertex_pos[0], zerovector, c,
- core::vector2d<f32>(0,1));
- f->vertices[1] = video::S3DVertex(vertex_pos[1], zerovector, c,
- core::vector2d<f32>(abs_scale,1));
- f->vertices[2] = video::S3DVertex(vertex_pos[2], zerovector, c,
- core::vector2d<f32>(abs_scale,0));
- f->vertices[3] = video::S3DVertex(vertex_pos[3], zerovector, c,
- core::vector2d<f32>(0,0));
-
- f->material = material;
-
- return f;
+ if (!isValidPosition(p))
+ return m_parent->getNodeNoEx(getPosRelative() + p, is_valid_position);
+
+ if (!data) {
+ if (is_valid_position)
+ *is_valid_position = false;
+ return {CONTENT_IGNORE};
+ }
+ if (is_valid_position)
+ *is_valid_position = true;
+ return data[p.Z * zstride + p.Y * ystride + p.X];
}
-
-/*
- Parameters must consist of air and !air.
- Order doesn't matter.
- If either of the nodes doesn't exist, light is 0.
-*/
-u8 MapBlock::getFaceLight(v3s16 p, v3s16 face_dir)
+std::string MapBlock::getModifiedReasonString()
{
- try{
- MapNode n = getNodeParent(p);
- MapNode n2 = getNodeParent(p + face_dir);
- u8 light;
- /*if(n.solidness() < n2.solidness())
- light = n.getLight();
- else
- light = n2.getLight();*/
- if(n.getLight() > n2.getLight())
- light = n.getLight();
- else
- light = n2.getLight();
+ std::string reason;
- // Make some nice difference to different sides
- if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1)
- light = diminish_light(diminish_light(light));
- else if(face_dir.X == -1 || face_dir.Z == -1)
- light = diminish_light(light);
+ const u32 ubound = MYMIN(sizeof(m_modified_reason) * CHAR_BIT,
+ ARRLEN(modified_reason_strings));
- return light;
- }
- catch(InvalidPositionException &e)
- {
- return 0;
+ for (u32 i = 0; i != ubound; i++) {
+ if ((m_modified_reason & (1 << i)) == 0)
+ continue;
+
+ reason += modified_reason_strings[i];
+ reason += ", ";
}
+
+ if (reason.length() > 2)
+ reason.resize(reason.length() - 2);
+
+ return reason;
}
-/*
- Gets node material from any place relative to block.
- Returns CONTENT_IGNORE if doesn't exist or should not be drawn.
-*/
-u8 MapBlock::getNodeTile(v3s16 p)
+void MapBlock::copyTo(VoxelManipulator &dst)
{
- try{
- MapNode n = getNodeParent(p);
-
- return content_tile(n.d);
- }
- catch(InvalidPositionException &e)
- {
- return CONTENT_IGNORE;
- }
+ v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
+ VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
+
+ // Copy from data to VoxelManipulator
+ dst.copyFrom(data, data_area, v3s16(0,0,0),
+ getPosRelative(), data_size);
}
-/*
- startpos:
- translate_dir: unit vector with only one of x, y or z
- face_dir: unit vector with only one of x, y or z
-*/
-void MapBlock::updateFastFaceRow(v3s16 startpos,
- u16 length,
- v3s16 translate_dir,
- v3s16 face_dir,
- core::list<FastFace*> &dest)
+void MapBlock::copyFrom(VoxelManipulator &dst)
{
+ v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
+ VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
+
+ // Copy from VoxelManipulator to data
+ dst.copyTo(data, data_area, v3s16(0,0,0),
+ getPosRelative(), data_size);
+}
+
+void MapBlock::actuallyUpdateDayNightDiff()
+{
+ INodeDefManager *nodemgr = m_gamedef->ndef();
+
+ // Running this function un-expires m_day_night_differs
+ m_day_night_differs_expired = false;
+
+ if (!data) {
+ m_day_night_differs = false;
+ return;
+ }
+
+ bool differs = false;
+
/*
- Precalculate some variables
+ Check if any lighting value differs
*/
- v3f translate_dir_f(translate_dir.X, translate_dir.Y,
- translate_dir.Z); // floating point conversion
- v3f face_dir_f(face_dir.X, face_dir.Y,
- face_dir.Z); // floating point conversion
- v3f posRelative_f(getPosRelative().X, getPosRelative().Y,
- getPosRelative().Z); // floating point conversion
-
- v3s16 p = startpos;
+
+ MapNode previous_n(CONTENT_IGNORE);
+ for (u32 i = 0; i < nodecount; 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;
+ }
+
/*
- The light in the air lights the surface is taken from
- the node that is air.
+ If some lighting values differ, check if the whole thing is
+ just air. If it is just air, differs = false
*/
- u8 light = getFaceLight(p, face_dir);
-
- u16 continuous_tiles_count = 0;
-
- u8 tile0 = getNodeTile(p);
- u8 tile1 = getNodeTile(p + face_dir);
-
- for(u16 j=0; j<length; j++)
- {
- bool next_is_different = true;
-
- v3s16 p_next;
- u8 tile0_next = 0;
- u8 tile1_next = 0;
- u8 light_next = 0;
-
- if(j != length - 1){
- p_next = p + translate_dir;
- tile0_next = getNodeTile(p_next);
- tile1_next = getNodeTile(p_next + face_dir);
- light_next = getFaceLight(p_next, face_dir);
-
- if(tile0_next == tile0
- && tile1_next == tile1
- && light_next == light)
- {
- next_is_different = false;
+ if (differs) {
+ bool only_air = true;
+ for (u32 i = 0; i < nodecount; i++) {
+ MapNode &n = data[i];
+ if (n.getContent() != CONTENT_AIR) {
+ only_air = false;
+ break;
}
}
+ if (only_air)
+ differs = false;
+ }
+
+ // Set member variable
+ m_day_night_differs = differs;
+}
- continuous_tiles_count++;
-
- if(next_is_different)
+void MapBlock::expireDayNightDiff()
+{
+ if (!data) {
+ m_day_night_differs = false;
+ m_day_night_differs_expired = false;
+ return;
+ }
+
+ 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--)
{
- /*
- Create a face if there should be one
- */
- u8 mf = face_contents(tile0, tile1);
-
- if(mf != 0)
- {
- // Floating point conversion of the position vector
- v3f pf(p.X, p.Y, p.Z);
- // Center point of face (kind of)
- v3f sp = pf - ((f32)continuous_tiles_count / 2. - 0.5) * translate_dir_f;
- v3f scale(1,1,1);
- if(translate_dir.X != 0){
- scale.X = continuous_tiles_count;
- }
- if(translate_dir.Y != 0){
- scale.Y = continuous_tiles_count;
- }
- if(translate_dir.Z != 0){
- scale.Z = continuous_tiles_count;
- }
-
- FastFace *f;
+ MapNode n = getNodeRef(p2d.X, y, p2d.Y);
+ if (m_gamedef->ndef()->get(n).walkable) {
+ if(y == MAP_BLOCKSIZE-1)
+ return -2;
- // If node at sp (tile0) is more solid
- if(mf == 1)
- {
- f = makeFastFace(tile0, light,
- sp, face_dir_f, scale,
- posRelative_f);
- }
- // If node at sp is less solid (mf == 2)
- else
- {
- f = makeFastFace(tile1, light,
- sp+face_dir_f, -1*face_dir_f, scale,
- posRelative_f);
- }
- dest.push_back(f);
+ return y;
}
-
- continuous_tiles_count = 0;
- tile0 = tile0_next;
- tile1 = tile1_next;
- light = light_next;
}
-
- p = p_next;
+ return -1;
+ }
+ catch(InvalidPositionException &e)
+ {
+ return -3;
}
}
/*
- This is used because CMeshBuffer::append() is very slow
+ Serialization
*/
-struct PreMeshBuffer
+// 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];
+static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
+ INodeDefManager *nodedef)
{
- video::SMaterial material;
- core::array<u16> indices;
- core::array<video::S3DVertex> vertices;
-};
+ memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t));
-class MeshCollector
-{
-public:
- void append(
- video::SMaterial material,
- const video::S3DVertex* const vertices,
- u32 numVertices,
- const u16* const indices,
- u32 numIndices
- )
- {
- PreMeshBuffer *p = NULL;
- for(u32 i=0; i<m_prebuffers.size(); i++)
- {
- PreMeshBuffer &pp = m_prebuffers[i];
- if(pp.material != material)
- continue;
+ std::set<content_t> 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;
- p = &pp;
- break;
+ // Try to find an existing mapping
+ if (getBlockNodeIdMapping_mapping[global_id] != 0xFFFF) {
+ id = getBlockNodeIdMapping_mapping[global_id];
}
-
- if(p == NULL)
+ else
{
- PreMeshBuffer pp;
- pp.material = material;
- m_prebuffers.push_back(pp);
- p = &m_prebuffers[m_prebuffers.size()-1];
+ // We have to assign a new mapping
+ id = id_counter++;
+ getBlockNodeIdMapping_mapping[global_id] = id;
+
+ const ContentFeatures &f = nodedef->get(global_id);
+ const std::string &name = f.name;
+ if (name.empty())
+ unknown_contents.insert(global_id);
+ else
+ nimap->set(id, name);
}
- u32 vertex_count = p->vertices.size();
- for(u32 i=0; i<numIndices; i++)
- {
- u32 j = indices[i] + vertex_count;
- if(j > 65535)
- {
- dstream<<"FIXME: Meshbuffer ran out of indices"<<std::endl;
- // NOTE: Fix is to just add an another MeshBuffer
- }
- p->indices.push_back(j);
+ // Update the MapNode
+ nodes[i].setContent(id);
+ }
+ for (u16 unknown_content : unknown_contents) {
+ errorstream << "getBlockNodeIdMapping(): IGNORING ERROR: "
+ << "Name for node id " << unknown_content << " not known" << std::endl;
+ }
+}
+// Correct ids in the block to match nodedef based on names.
+// Unknown ones are added to nodedef.
+// Will not update itself to match id-name pairs in nodedef.
+static void correctBlockNodeIds(const NameIdMapping *nimap, MapNode *nodes,
+ IGameDef *gamedef)
+{
+ INodeDefManager *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::unordered_set<content_t> unnamed_contents;
+ std::unordered_set<std::string> 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;
}
- for(u32 i=0; i<numVertices; i++)
- {
- p->vertices.push_back(vertices[i]);
+
+ std::string name;
+ if (!nimap->getName(local_id, name)) {
+ unnamed_contents.insert(local_id);
+ previous_exists = false;
+ continue;
}
- }
- void fillMesh(scene::SMesh *mesh)
- {
- /*dstream<<"Filling mesh with "<<m_prebuffers.size()
- <<" meshbuffers"<<std::endl;*/
- for(u32 i=0; i<m_prebuffers.size(); i++)
- {
- PreMeshBuffer &p = m_prebuffers[i];
-
- /*dstream<<"p.vertices.size()="<<p.vertices.size()
- <<", p.indices.size()="<<p.indices.size()
- <<std::endl;*/
-
- // Create meshbuffer
-
- // This is a "Standard MeshBuffer",
- // it's a typedeffed CMeshBuffer<video::S3DVertex>
- scene::SMeshBuffer *buf = new scene::SMeshBuffer();
- // Set material
- buf->Material = p.material;
- //((scene::SMeshBuffer*)buf)->Material = p.material;
- // Use VBO
- //buf->setHardwareMappingHint(scene::EHM_STATIC);
- // Add to mesh
- mesh->addMeshBuffer(buf);
- // Mesh grabbed it
- buf->drop();
-
- buf->append(p.vertices.pointer(), p.vertices.size(),
- p.indices.pointer(), p.indices.size());
+ content_t global_id;
+ if (!nodedef->getId(name, global_id)) {
+ global_id = gamedef->allocateUnknownNodeId(name);
+ 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;
}
-private:
- core::array<PreMeshBuffer> m_prebuffers;
-};
+ for (const content_t c: unnamed_contents) {
+ errorstream << "correctBlockNodeIds(): IGNORING ERROR: "
+ << "Block contains id " << c
+ << " with no name mapping" << std::endl;
+ }
+ for (const std::string &node_name: unallocatable_contents) {
+ errorstream << "correctBlockNodeIds(): IGNORING ERROR: "
+ << "Could not allocate global id for node name \""
+ << node_name << "\"" << std::endl;
+ }
+}
-void MapBlock::updateMesh()
+void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
{
- /*v3s16 p = getPosRelative();
- std::cout<<"MapBlock("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<"::updateMesh(): ";*/
- //<<"::updateMesh()"<<std::endl;
-
- /*
- TODO: Change this to directly generate the mesh (and get rid
- of FastFaces)
- */
+ if(!ser_ver_supported(version))
+ throw VersionMismatchException("ERROR: MapBlock format not supported");
- core::list<FastFace*> *fastfaces_new = new core::list<FastFace*>;
-
- /*
- We are including the faces of the trailing edges of the block.
- This means that when something changes, the caller must
- also update the meshes of the blocks at the leading edges.
- */
+ if (!data)
+ throw SerializationError("ERROR: Not writing dummy block.");
- /*
- Go through every y,z and get top faces in rows of x+
- */
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- //for(s16 y=-1; y<MAP_BLOCKSIZE; y++){
- for(s16 z=0; z<MAP_BLOCKSIZE; z++){
- updateFastFaceRow(v3s16(0,y,z), MAP_BLOCKSIZE,
- v3s16(1,0,0),
- v3s16(0,1,0),
- *fastfaces_new);
- }
+ FATAL_ERROR_IF(version < SER_FMT_VER_LOWEST_WRITE, "Serialisation version error");
+
+ // First byte
+ u8 flags = 0;
+ if(is_underground)
+ flags |= 0x01;
+ if(getDayNightDiff())
+ flags |= 0x02;
+ if (!m_generated)
+ flags |= 0x08;
+ writeU8(os, flags);
+ if (version >= 27) {
+ writeU16(os, m_lighting_complete);
}
+
/*
- Go through every x,y and get right faces in rows of z+
+ Bulk node data
*/
- for(s16 x=0; x<MAP_BLOCKSIZE; x++){
- //for(s16 x=-1; x<MAP_BLOCKSIZE; x++){
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- updateFastFaceRow(v3s16(x,y,0), MAP_BLOCKSIZE,
- v3s16(0,0,1),
- v3s16(1,0,0),
- *fastfaces_new);
- }
+ NameIdMapping nimap;
+ if(disk)
+ {
+ MapNode *tmp_nodes = new MapNode[nodecount];
+ for(u32 i=0; i<nodecount; i++)
+ tmp_nodes[i] = data[i];
+ getBlockNodeIdMapping(&nimap, tmp_nodes, m_gamedef->ndef());
+
+ 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);
+ delete[] tmp_nodes;
+ }
+ 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);
}
+
/*
- Go through every y,z and get back faces in rows of x+
+ Node metadata
*/
- for(s16 z=0; z<MAP_BLOCKSIZE; z++){
- //for(s16 z=-1; z<MAP_BLOCKSIZE; z++){
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- updateFastFaceRow(v3s16(0,y,z), MAP_BLOCKSIZE,
- v3s16(1,0,0),
- v3s16(0,0,1),
- *fastfaces_new);
- }
- }
+ std::ostringstream oss(std::ios_base::binary);
+ m_node_metadata.serialize(oss, version, disk);
+ compressZlib(oss.str(), os);
- scene::SMesh *mesh_new = NULL;
-
- mesh_new = new scene::SMesh();
-
- if(fastfaces_new->getSize() > 0)
+ /*
+ Data that goes to disk, but not the network
+ */
+ if(disk)
{
- MeshCollector collector;
+ if(version <= 24){
+ // Node timers
+ m_node_timers.serialize(os, version);
+ }
- core::list<FastFace*>::Iterator i = fastfaces_new->begin();
+ // Static objects
+ m_static_objects.serialize(os);
- for(; i != fastfaces_new->end(); i++)
- {
- FastFace *f = *i;
+ // Timestamp
+ writeU32(os, getTimestamp());
- const u16 indices[] = {0,1,2,2,3,0};
+ // Write block-specific node definition id mapping
+ nimap.serialize(os);
- collector.append(g_materials[f->material], f->vertices, 4,
- indices, 6);
+ if(version >= 25){
+ // Node timers
+ m_node_timers.serialize(os, version);
}
-
- collector.fillMesh(mesh_new);
-
- // Use VBO for mesh (this just would set this for ever buffer)
- //mesh_new->setHardwareMappingHint(scene::EHM_STATIC);
-
- /*std::cout<<"MapBlock has "<<fastfaces_new->getSize()<<" faces "
- <<"and uses "<<mesh_new->getMeshBufferCount()
- <<" materials (meshbuffers)"<<std::endl;*/
}
-
- /*
- Clear temporary FastFaces
- */
+}
- core::list<FastFace*>::Iterator i;
- i = fastfaces_new->begin();
- for(; i != fastfaces_new->end(); i++)
- {
- delete *i;
+void MapBlock::serializeNetworkSpecific(std::ostream &os)
+{
+ if (!data) {
+ throw SerializationError("ERROR: Not writing dummy block.");
}
- fastfaces_new->clear();
- delete fastfaces_new;
-
- /*
- Add special graphics:
- - torches
-
- TODO: Optimize by using same meshbuffer for same textures
- */
-
- /*scene::ISceneManager *smgr = NULL;
- video::IVideoDriver* driver = NULL;
- if(g_device)
- {
- smgr = g_device->getSceneManager();
- driver = smgr->getVideoDriver();
- }*/
-
- for(s16 z=0; z<MAP_BLOCKSIZE; z++)
- for(s16 y=0; y<MAP_BLOCKSIZE; y++)
- for(s16 x=0; x<MAP_BLOCKSIZE; x++)
- {
- v3s16 p(x,y,z);
-
- MapNode &n = getNodeRef(x,y,z);
-
- if(n.d == CONTENT_LIGHT)
- {
- //scene::IMeshBuffer *buf = new scene::SMeshBuffer();
- scene::SMeshBuffer *buf = new scene::SMeshBuffer();
- video::SColor c(255,255,255,255);
- video::S3DVertex vertices[4] =
- {
- video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,BS/2,0, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c, 0,0),
- };
+ writeU8(os, 1); // version
+ writeF1000(os, 0); // deprecated heat
+ writeF1000(os, 0); // deprecated humidity
+}
- v3s16 dir = unpackDir(n.dir);
+void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
+{
+ if(!ser_ver_supported(version))
+ throw VersionMismatchException("ERROR: MapBlock format not supported");
- for(s32 i=0; i<4; i++)
- {
- if(dir == v3s16(1,0,0))
- vertices[i].Pos.rotateXZBy(0);
- if(dir == v3s16(-1,0,0))
- vertices[i].Pos.rotateXZBy(180);
- if(dir == v3s16(0,0,1))
- vertices[i].Pos.rotateXZBy(90);
- if(dir == v3s16(0,0,-1))
- vertices[i].Pos.rotateXZBy(-90);
- if(dir == v3s16(0,-1,0))
- vertices[i].Pos.rotateXZBy(45);
- if(dir == v3s16(0,1,0))
- vertices[i].Pos.rotateXZBy(-45);
-
- vertices[i].Pos += intToFloat(p + getPosRelative());
- }
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())<<std::endl);
- u16 indices[] = {0,1,2,2,3,0};
- buf->append(vertices, 4, indices, 6);
-
- // Set material
- buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
- buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
- buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
- //buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- buf->getMaterial().MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- if(dir == v3s16(0,-1,0))
- buf->getMaterial().setTexture(0,
- g_texturecache.get("torch_on_floor"));
- else if(dir == v3s16(0,1,0))
- buf->getMaterial().setTexture(0,
- g_texturecache.get("torch_on_ceiling"));
- // For backwards compatibility
- else if(dir == v3s16(0,0,0))
- buf->getMaterial().setTexture(0,
- g_texturecache.get("torch_on_floor"));
- else
- buf->getMaterial().setTexture(0, g_texturecache.get("torch"));
+ m_day_night_differs_expired = false;
- // Add to mesh
- mesh_new->addMeshBuffer(buf);
- buf->drop();
- }
+ if(version <= 21)
+ {
+ deSerialize_pre22(is, version, disk);
+ return;
}
+ u8 flags = readU8(is);
+ 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;
+
/*
- Do some stuff to the mesh
+ Bulk node data
*/
-
- mesh_new->recalculateBoundingBox();
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Bulk node data"<<std::endl);
+ u8 content_width = readU8(is);
+ u8 params_width = readU8(is);
+ if(content_width != 1 && content_width != 2)
+ throw SerializationError("MapBlock::deSerialize(): invalid content_width");
+ if(params_width != 2)
+ throw SerializationError("MapBlock::deSerialize(): invalid params_width");
+ MapNode::deSerializeBulk(is, version, data, nodecount,
+ content_width, params_width, true);
/*
- Delete new mesh if it is empty
+ NodeMetadata
*/
-
- if(mesh_new->getMeshBufferCount() == 0)
- {
- mesh_new->drop();
- mesh_new = NULL;
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Node metadata"<<std::endl);
+ // Ignore errors
+ try {
+ std::ostringstream oss(std::ios_base::binary);
+ decompressZlib(is, oss);
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ 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->idef());
+ } catch(SerializationError &e) {
+ warningstream<<"MapBlock::deSerialize(): Ignoring an error"
+ <<" while deserializing node metadata at ("
+ <<PP(getPos())<<": "<<e.what()<<std::endl;
}
/*
- Replace the mesh
+ Data that is only on disk
*/
+ if(disk)
+ {
+ // Node timers
+ if(version == 23){
+ // Read unused zero
+ readU8(is);
+ }
+ if(version == 24){
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Node timers (ver==24)"<<std::endl);
+ m_node_timers.deSerialize(is, version);
+ }
- mesh_mutex.Lock();
+ // Static objects
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Static objects"<<std::endl);
+ m_static_objects.deSerialize(is);
+
+ // Timestamp
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Timestamp"<<std::endl);
+ setTimestamp(readU32(is));
+ m_disk_timestamp = m_timestamp;
+
+ // Dynamically re-set ids based on node names
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": NameIdMapping"<<std::endl);
+ NameIdMapping nimap;
+ nimap.deSerialize(is);
+ correctBlockNodeIds(&nimap, data, m_gamedef);
+
+ if(version >= 25){
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Node timers (ver>=25)"<<std::endl);
+ m_node_timers.deSerialize(is, version);
+ }
+ }
- scene::SMesh *mesh_old = mesh;
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Done."<<std::endl);
+}
- mesh = mesh_new;
-
- if(mesh_old != NULL)
+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)
{
- // Remove hardware buffers of meshbuffers of mesh
- // NOTE: No way, this runs in a different thread and everything
- /*u32 c = mesh_old->getMeshBufferCount();
- for(u32 i=0; i<c; i++)
- {
- IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
- }*/
- // Drop the mesh
- mesh_old->drop();
- //delete mesh_old;
+ warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
+ <<": "<<e.what()<<std::endl;
}
-
- mesh_mutex.Unlock();
-
- //std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
}
/*
- 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 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.
-
- At the moment, all sunlighted nodes are added to light_sources.
- TODO: This could be optimized.
+ Legacy serialization
*/
-bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources)
+
+void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
{
- // 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; x<MAP_BLOCKSIZE; x++)
- {
- for(s16 z=0; z<MAP_BLOCKSIZE; z++)
+ // Initialize default flags
+ is_underground = false;
+ m_day_night_differs = false;
+ m_lighting_complete = 0xFFFF;
+ m_generated = true;
+
+ // Make a temporary buffer
+ u32 ser_length = MapNode::serializedLength(version);
+ SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
+
+ // These have no compression
+ if (version <= 3 || version == 5 || version == 6) {
+ char tmp;
+ is.read(&tmp, 1);
+ 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(std::string(FUNCTION_NAME)
+ + ": not enough input data");
+ } else if (version <= 10) {
+ u8 t8;
+ is.read((char *)&t8, 1);
+ is_underground = t8;
+
{
- bool no_sunlight = false;
- bool no_top_block = false;
- // Check if node above block has sunlight
- try{
- MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
- if(n.getLight() != LIGHT_SUN)
- {
- /*if(is_underground)
- {
- no_sunlight = true;
- }*/
- no_sunlight = true;
- }
+ // Uncompress and set material data
+ std::ostringstream os(std::ios_base::binary);
+ decompress(is, os, version);
+ std::string s = os.str();
+ if (s.size() != nodecount)
+ throw SerializationError(std::string(FUNCTION_NAME)
+ + ": not enough input data");
+ for (u32 i = 0; i < s.size(); i++) {
+ databuf_nodelist[i*ser_length] = s[i];
}
- catch(InvalidPositionException &e)
- {
- no_top_block = true;
-
- // TODO: This makes over-ground roofed places sunlighted
- // Assume sunlight, unless is_underground==true
- if(is_underground)
- {
- no_sunlight = true;
- }
-
- // TODO: There has to be some way to allow this behaviour
- // As of now, it just makes everything dark.
- // No sunlight here
- //no_sunlight = true;
+ }
+ {
+ // Uncompress and set param data
+ std::ostringstream os(std::ios_base::binary);
+ decompress(is, os, version);
+ std::string s = os.str();
+ if (s.size() != nodecount)
+ throw SerializationError(std::string(FUNCTION_NAME)
+ + ": not enough input data");
+ for (u32 i = 0; i < s.size(); i++) {
+ databuf_nodelist[i*ser_length + 1] = s[i];
}
+ }
- /*std::cout<<"("<<x<<","<<z<<"): "
- <<"no_top_block="<<no_top_block
- <<", is_underground="<<is_underground
- <<", no_sunlight="<<no_sunlight
- <<std::endl;*/
-
- s16 y = MAP_BLOCKSIZE-1;
-
- if(no_sunlight == false)
- {
- // Continue spreading sunlight downwards through transparent
- // nodes
- for(; y >= 0; y--)
- {
- v3s16 pos(x, y, z);
-
- MapNode &n = getNodeRef(pos);
-
- if(n.sunlight_propagates())
- {
- n.setLight(LIGHT_SUN);
-
- light_sources.insert(pos_relative + pos, true);
- }
- else{
- break;
- }
- }
+ 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(std::string(FUNCTION_NAME)
+ + ": not enough input data");
+ for (u32 i = 0; i < s.size(); i++) {
+ databuf_nodelist[i*ser_length + 2] = s[i];
}
+ }
+ } else { // All other versions (10 to 21)
+ u8 flags;
+ is.read((char*)&flags, 1);
+ is_underground = (flags & 0x01) != 0;
+ m_day_night_differs = (flags & 0x02) != 0;
+ if(version >= 18)
+ 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(std::string(FUNCTION_NAME)
+ + ": decompress resulted in size other than nodecount*3");
+
+ // deserialize nodes from buffer
+ for (u32 i = 0; i < nodecount; i++) {
+ databuf_nodelist[i*ser_length] = s[i];
+ databuf_nodelist[i*ser_length + 1] = s[i+nodecount];
+ databuf_nodelist[i*ser_length + 2] = s[i+nodecount*2];
+ }
- bool sunlight_should_go_down = (y==-1);
-
- // Fill rest with black (only transparent ones)
- for(; y >= 0; y--){
- v3s16 pos(x, y, z);
-
- MapNode &n = getNodeRef(pos);
-
- if(n.light_propagates())
- {
- n.setLight(0);
- }
- else{
- break;
+ /*
+ NodeMetadata
+ */
+ if (version >= 14) {
+ // Ignore errors
+ try {
+ if (version <= 15) {
+ std::string data = deSerializeString(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::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->idef());
}
+ } catch(SerializationError &e) {
+ warningstream<<"MapBlock::deSerialize(): Ignoring an error"
+ <<" while deserializing node metadata"<<std::endl;
}
+ }
+ }
- /*
- If the block below hasn't already been marked invalid:
+ // Deserialize node data
+ for (u32 i = 0; i < nodecount; i++) {
+ data[i].deSerialize(&databuf_nodelist[i * ser_length], version);
+ }
- Check if the node below the block has proper sunlight at top.
- If not, the block below is invalid.
-
- Ignore non-transparent nodes as they always have no light
- */
- try
- {
- if(block_below_is_valid)
- {
- MapNode n = getNodeParent(v3s16(x, -1, z));
- if(n.light_propagates())
- {
- if(n.getLight() == LIGHT_SUN
- && sunlight_should_go_down == false)
- block_below_is_valid = false;
- else if(n.getLight() != LIGHT_SUN
- && sunlight_should_go_down == true)
- block_below_is_valid = false;
- }
- }//if
- }//try
- catch(InvalidPositionException &e)
- {
- /*std::cout<<"InvalidBlockException for bottom block node"
- <<std::endl;*/
- // Just no block below, no need to panic.
+ if (disk) {
+ /*
+ Versions up from 9 have block objects. (DEPRECATED)
+ */
+ if (version >= 9) {
+ u16 count = readU16(is);
+ // Not supported and length not known if count is not 0
+ if(count != 0){
+ warningstream<<"MapBlock::deSerialize_pre22(): "
+ <<"Ignoring stuff coming at and after MBOs"<<std::endl;
+ return;
}
}
- }
- return block_below_is_valid;
-}
-
-void MapBlock::copyTo(VoxelManipulator &dst)
-{
- v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
- VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
-
- dst.copyFrom(data, data_area, v3s16(0,0,0),
- getPosRelative(), data_size);
-}
+ /*
+ Versions up from 15 have static objects.
+ */
+ if (version >= 15)
+ m_static_objects.deSerialize(is);
+
+ // Timestamp
+ if (version >= 17) {
+ setTimestamp(readU32(is));
+ m_disk_timestamp = m_timestamp;
+ } else {
+ setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+ }
-/*void getPseudoObjects(v3f origin, f32 max_d,
- core::array<DistanceSortedObject> &dest)
-{
-}*/
+ // Dynamically re-set ids based on node names
+ NameIdMapping nimap;
+ // If supported, read node definition id mapping
+ if (version >= 21) {
+ nimap.deSerialize(is);
+ // Else set the legacy mapping
+ } else {
+ content_mapnode_get_name_id_mapping(&nimap);
+ }
+ correctBlockNodeIds(&nimap, data, m_gamedef);
+ }
-/*
- Serialization
-*/
-void MapBlock::serialize(std::ostream &os, u8 version)
-{
- if(!ser_ver_supported(version))
- throw VersionMismatchException("ERROR: MapBlock format not supported");
-
- if(data == NULL)
+ // Legacy data changes
+ // This code has to convert from pre-22 to post-22 format.
+ INodeDefManager *nodedef = m_gamedef->ndef();
+ for(u32 i=0; i<nodecount; i++)
{
- throw SerializationError("ERROR: Not writing dummy block.");
- }
-
- // These have no compression
- if(version <= 3 || version == 5 || version == 6)
- {
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
- u32 buflen = 1 + nodecount * MapNode::serializedLength(version);
- SharedBuffer<u8> dest(buflen);
-
- dest[0] = is_underground;
- for(u32 i=0; i<nodecount; i++)
+ const ContentFeatures &f = nodedef->get(data[i].getContent());
+ // Mineral
+ if(nodedef->getId("default:stone") == data[i].getContent()
+ && data[i].getParam1() == 1)
{
- u32 s = 1 + i * MapNode::serializedLength(version);
- data[i].serialize(&dest[s], version);
+ data[i].setContent(nodedef->getId("default:stone_with_coal"));
+ data[i].setParam1(0);
}
-
- os.write((char*)*dest, dest.getSize());
- }
- // All otherversions
- else
- {
- /*
- With compression.
- Compress the materials and the params separately.
- */
-
- // First byte
- os.write((char*)&is_underground, 1);
-
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
- // Get and compress materials
- SharedBuffer<u8> materialdata(nodecount);
- for(u32 i=0; i<nodecount; i++)
+ else if(nodedef->getId("default:stone") == data[i].getContent()
+ && data[i].getParam1() == 2)
{
- materialdata[i] = data[i].d;
+ data[i].setContent(nodedef->getId("default:stone_with_iron"));
+ data[i].setParam1(0);
}
- compress(materialdata, os, version);
-
- // Get and compress params
- SharedBuffer<u8> paramdata(nodecount);
- for(u32 i=0; i<nodecount; i++)
+ // facedir_simple
+ if(f.legacy_facedir_simple)
{
- paramdata[i] = data[i].param;
+ data[i].setParam2(data[i].getParam1());
+ data[i].setParam1(0);
}
- compress(paramdata, os, version);
-
- if(version >= 10)
+ // wall_mounted
+ if(f.legacy_wallmounted)
{
- // Get and compress pressure
- SharedBuffer<u8> pressuredata(nodecount);
- for(u32 i=0; i<nodecount; i++)
+ u8 wallmounted_new_to_old[8] = {0x04, 0x08, 0x01, 0x02, 0x10, 0x20, 0, 0};
+ u8 dir_old_format = data[i].getParam2();
+ u8 dir_new_format = 0;
+ for(u8 j=0; j<8; j++)
{
- pressuredata[i] = data[i].pressure;
+ if((dir_old_format & wallmounted_new_to_old[j]) != 0)
+ {
+ dir_new_format = j;
+ break;
+ }
}
- compress(pressuredata, os, version);
+ data[i].setParam2(dir_new_format);
}
}
+
}
-void MapBlock::deSerialize(std::istream &is, u8 version)
+/*
+ Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block)
{
- if(!ser_ver_supported(version))
- throw VersionMismatchException("ERROR: MapBlock format not supported");
+ if(block == NULL)
+ return "NULL";
- // These have no compression
- if(version <= 3 || version == 5 || version == 6)
+ std::ostringstream desc;
+
+ v3s16 p = block->getPos();
+ char spos[25];
+ snprintf(spos, sizeof(spos), "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
+ desc<<spos;
+
+ switch(block->getModified())
{
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
- char tmp;
- is.read(&tmp, 1);
- if(is.gcount() != 1)
- throw SerializationError
- ("MapBlock::deSerialize: no enough input data");
- is_underground = tmp;
- for(u32 i=0; i<nodecount; i++)
- {
- s32 len = MapNode::serializedLength(version);
- SharedBuffer<u8> d(len);
- is.read((char*)*d, len);
- if(is.gcount() != len)
- throw SerializationError
- ("MapBlock::deSerialize: no enough input data");
- data[i].deSerialize(*d, version);
- }
+ case MOD_STATE_CLEAN:
+ desc<<"CLEAN, ";
+ break;
+ case MOD_STATE_WRITE_AT_UNLOAD:
+ desc<<"WRITE_AT_UNLOAD, ";
+ break;
+ case MOD_STATE_WRITE_NEEDED:
+ desc<<"WRITE_NEEDED, ";
+ break;
+ default:
+ desc<<"unknown getModified()="+itos(block->getModified())+", ";
}
- // All other versions
+
+ if(block->isGenerated())
+ desc<<"is_gen [X], ";
else
- {
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+ desc<<"is_gen [ ], ";
- u8 t8;
- is.read((char*)&t8, 1);
- is_underground = t8;
+ if(block->getIsUnderground())
+ desc<<"is_ug [X], ";
+ else
+ desc<<"is_ug [ ], ";
+ desc<<"lighting_complete: "<<block->getLightingComplete()<<", ";
+
+ if(block->isDummy())
+ {
+ desc<<"Dummy, ";
+ }
+ else
+ {
+ bool full_ignore = true;
+ bool some_ignore = false;
+ bool full_air = true;
+ bool some_air = false;
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
- // Uncompress and set material 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<s.size(); i++)
- {
- data[i].d = s[i];
- }
- }
- {
- // Uncompress and set param 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<s.size(); i++)
- {
- data[i].param = s[i];
- }
- }
-
- if(version >= 10)
- {
- // Uncompress and set pressure 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<s.size(); i++)
- {
- data[i].pressure = s[i];
- }
+ v3s16 p(x0,y0,z0);
+ MapNode n = block->getNodeNoEx(p);
+ content_t c = n.getContent();
+ if(c == CONTENT_IGNORE)
+ some_ignore = true;
+ else
+ full_ignore = false;
+ if(c == CONTENT_AIR)
+ some_air = true;
+ else
+ full_air = false;
}
+
+ desc<<"content {";
+
+ std::ostringstream ss;
+
+ if(full_ignore)
+ ss<<"IGNORE (full), ";
+ else if(some_ignore)
+ ss<<"IGNORE, ";
+
+ if(full_air)
+ ss<<"AIR (full), ";
+ else if(some_air)
+ ss<<"AIR, ";
+
+ if(ss.str().size()>=2)
+ desc<<ss.str().substr(0, ss.str().size()-2);
+
+ desc<<"}, ";
}
+
+ return desc.str().substr(0, desc.str().size()-2);
}