/*
-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_settings
-#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
-void MeshMakeData::fill(u32 daynight_ratio, MapBlock *block)
-{
- m_daynight_ratio = daynight_ratio;
- m_blockpos = block->getPos();
-
- v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE;
-
- /*
- There is no harm not copying the TempMods of the neighbors
- because they are already copied to this block
- */
- m_temp_mods.clear();
- block->copyTempMods(m_temp_mods);
-
- /*
- Copy data
- */
-
- // Allocate this block + neighbors
- m_vmanip.clear();
- m_vmanip.addArea(VoxelArea(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE,
- blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE*2-v3s16(1,1,1)));
-
- {
- //TimeTaker timer("copy central block data");
- // 0ms
-
- // Copy our data
- block->copyTo(m_vmanip);
- }
- {
- //TimeTaker timer("copy neighbor block data");
- // 0ms
-
- /*
- Copy neighbors. This is lightning fast.
- Copying only the borders would be *very* slow.
- */
-
- // Get map
- NodeContainer *parentcontainer = block->getParent();
- // This will only work if the parent is the map
- assert(parentcontainer->nodeContainerId() == NODECONTAINER_ID_MAP);
- // OK, we have the map!
- Map *map = (Map*)parentcontainer;
-
- for(u16 i=0; i<6; i++)
- {
- const v3s16 &dir = g_6dirs[i];
- v3s16 bp = m_blockpos + dir;
- MapBlock *b = map->getBlockNoCreateNoEx(bp);
- if(b)
- b->copyTo(m_vmanip);
- }
- }
-}
+#include "mapblock_mesh.h"
#endif
+#include "util/string.h"
+#include "util/serialize.h"
-/*
- Parameters must consist of air and !air.
- Order doesn't matter.
-
- If either of the nodes doesn't exist, light is 0.
-
- parameters:
- daynight_ratio: 0...1000
- n: getNodeParent(p)
- n2: getNodeParent(p + face_dir)
- face_dir: axis oriented unit vector from p to p2
-
- returns encoded light value.
-*/
-u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
- v3s16 face_dir)
-{
- try{
- u8 light;
- u8 l1 = n.getLightBlend(daynight_ratio);
- u8 l2 = n2.getLightBlend(daynight_ratio);
- if(l1 > l2)
- light = l1;
- else
- light = l2;
-
- // Make some nice difference to different sides
-
- // This makes light come from a corner
- /*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);*/
-
- // All neighboring faces have different shade (like in minecraft)
- if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1)
- light = diminish_light(diminish_light(light));
- else if(face_dir.Z == 1 || face_dir.Z == -1)
- light = diminish_light(light);
-
- return light;
- }
- catch(InvalidPositionException &e)
- {
- return 0;
- }
-}
-
-#ifndef SERVER
-
-/*
- vertex_dirs: v3s16[4]
-*/
-void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs)
-{
- /*
- If looked from outside the node towards the face, the corners are:
- 0: bottom-right
- 1: bottom-left
- 2: top-left
- 3: top-right
- */
- if(dir == v3s16(0,0,1))
- {
- // If looking towards z+, this is the face that is behind
- // the center point, facing towards z+.
- vertex_dirs[0] = v3s16(-1,-1, 1);
- vertex_dirs[1] = v3s16( 1,-1, 1);
- vertex_dirs[2] = v3s16( 1, 1, 1);
- vertex_dirs[3] = v3s16(-1, 1, 1);
- }
- else if(dir == v3s16(0,0,-1))
- {
- // faces towards Z-
- vertex_dirs[0] = v3s16( 1,-1,-1);
- vertex_dirs[1] = v3s16(-1,-1,-1);
- vertex_dirs[2] = v3s16(-1, 1,-1);
- vertex_dirs[3] = v3s16( 1, 1,-1);
- }
- else if(dir == v3s16(1,0,0))
- {
- // faces towards X+
- vertex_dirs[0] = v3s16( 1,-1, 1);
- vertex_dirs[1] = v3s16( 1,-1,-1);
- vertex_dirs[2] = v3s16( 1, 1,-1);
- vertex_dirs[3] = v3s16( 1, 1, 1);
- }
- else if(dir == v3s16(-1,0,0))
- {
- // faces towards X-
- vertex_dirs[0] = v3s16(-1,-1,-1);
- vertex_dirs[1] = v3s16(-1,-1, 1);
- vertex_dirs[2] = v3s16(-1, 1, 1);
- vertex_dirs[3] = v3s16(-1, 1,-1);
- }
- else if(dir == v3s16(0,1,0))
- {
- // faces towards Y+ (assume Z- as "down" in texture)
- vertex_dirs[0] = v3s16( 1, 1,-1);
- vertex_dirs[1] = v3s16(-1, 1,-1);
- vertex_dirs[2] = v3s16(-1, 1, 1);
- vertex_dirs[3] = v3s16( 1, 1, 1);
- }
- else if(dir == v3s16(0,-1,0))
- {
- // faces towards Y- (assume Z+ as "down" in texture)
- vertex_dirs[0] = v3s16( 1,-1, 1);
- vertex_dirs[1] = v3s16(-1,-1, 1);
- vertex_dirs[2] = v3s16(-1,-1,-1);
- vertex_dirs[3] = v3s16( 1,-1,-1);
- }
-}
-
-inline video::SColor lightColor(u8 alpha, u8 light)
-{
- return video::SColor(alpha,light,light,light);
-}
-
-void makeFastFace(TileSpec tile, u8 li0, u8 li1, u8 li2, u8 li3, v3f p,
- v3s16 dir, v3f scale, v3f posRelative_f,
- core::array<FastFace> &dest)
-{
- FastFace face;
-
- // Position is at the center of the cube.
- v3f pos = p * BS;
- posRelative_f *= BS;
-
- v3f vertex_pos[4];
- v3s16 vertex_dirs[4];
- getNodeVertexDirs(dir, vertex_dirs);
- for(u16 i=0; i<4; i++)
- {
- vertex_pos[i] = v3f(
- BS/2*vertex_dirs[i].X,
- BS/2*vertex_dirs[i].Y,
- BS/2*vertex_dirs[i].Z
- );
- }
-
- /*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);
-
- if(dir == v3s16(0,0,1))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(0);
- }
- else if(dir == v3s16(0,0,-1))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(180);
- }
- else if(dir == v3s16(1,0,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(-90);
- }
- else if(dir == v3s16(-1,0,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(90);
- }
- else if(dir == v3s16(0,1,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateYZBy(-90);
- }
- else if(dir == v3s16(0,-1,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateYZBy(90);
- }*/
-
- for(u16 i=0; i<4; 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 alpha = tile.alpha;
- /*u8 alpha = 255;
- if(tile.id == TILE_WATER)
- alpha = WATER_ALPHA;*/
-
- float x0 = tile.texture.pos.X;
- float y0 = tile.texture.pos.Y;
- float w = tile.texture.size.X;
- float h = tile.texture.size.Y;
-
- /*video::SColor c = lightColor(alpha, li);
-
- face.vertices[0] = video::S3DVertex(vertex_pos[0], v3f(0,1,0), c,
- core::vector2d<f32>(x0+w*abs_scale, y0+h));
- face.vertices[1] = video::S3DVertex(vertex_pos[1], v3f(0,1,0), c,
- core::vector2d<f32>(x0, y0+h));
- face.vertices[2] = video::S3DVertex(vertex_pos[2], v3f(0,1,0), c,
- core::vector2d<f32>(x0, y0));
- face.vertices[3] = video::S3DVertex(vertex_pos[3], v3f(0,1,0), c,
- core::vector2d<f32>(x0+w*abs_scale, y0));*/
-
- face.vertices[0] = video::S3DVertex(vertex_pos[0], v3f(0,1,0),
- lightColor(alpha, li0),
- core::vector2d<f32>(x0+w*abs_scale, y0+h));
- face.vertices[1] = video::S3DVertex(vertex_pos[1], v3f(0,1,0),
- lightColor(alpha, li1),
- core::vector2d<f32>(x0, y0+h));
- face.vertices[2] = video::S3DVertex(vertex_pos[2], v3f(0,1,0),
- lightColor(alpha, li2),
- core::vector2d<f32>(x0, y0));
- face.vertices[3] = video::S3DVertex(vertex_pos[3], v3f(0,1,0),
- lightColor(alpha, li3),
- core::vector2d<f32>(x0+w*abs_scale, y0));
-
- face.tile = tile;
- //DEBUG
- //f->tile = TILE_STONE;
-
- dest.push_back(face);
-}
-
-/*
- Gets node tile from any place relative to block.
- Returns TILE_NODE if doesn't exist or should not be drawn.
-*/
-TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir,
- NodeModMap &temp_mods)
-{
- TileSpec spec;
- spec = mn.getTile(face_dir);
-
- /*
- Check temporary modifications on this node
- */
- /*core::map<v3s16, NodeMod>::Node *n;
- n = m_temp_mods.find(p);
- // If modified
- if(n != NULL)
- {
- struct NodeMod mod = n->getValue();*/
- NodeMod mod;
- if(temp_mods.get(p, &mod))
- {
- if(mod.type == NODEMOD_CHANGECONTENT)
- {
- MapNode mn2(mod.param);
- spec = mn2.getTile(face_dir);
- }
- if(mod.type == NODEMOD_CRACK)
- {
- /*
- Get texture id, translate it to name, append stuff to
- name, get texture id
- */
-
- // Get original texture name
- u32 orig_id = spec.texture.id;
- std::string orig_name = g_texturesource->getTextureName(orig_id);
-
- // Create new texture name
- std::ostringstream os;
- os<<orig_name<<"^[crack"<<mod.param;
-
- // Get new texture
- u32 new_id = g_texturesource->getTextureId(os.str());
-
- /*dstream<<"MapBlock::getNodeTile(): Switching from "
- <<orig_name<<" to "<<os.str()<<" ("
- <<orig_id<<" to "<<new_id<<")"<<std::endl;*/
-
- spec.texture = g_texturesource->getTexture(new_id);
- }
- }
-
- return spec;
-}
-
-u8 getNodeContent(v3s16 p, MapNode mn, NodeModMap &temp_mods)
-{
- /*
- Check temporary modifications on this node
- */
- /*core::map<v3s16, NodeMod>::Node *n;
- n = m_temp_mods.find(p);
- // If modified
- if(n != NULL)
- {
- struct NodeMod mod = n->getValue();*/
- NodeMod mod;
- if(temp_mods.get(p, &mod))
- {
- if(mod.type == NODEMOD_CHANGECONTENT)
- {
- // Overrides content
- return mod.param;
- }
- if(mod.type == NODEMOD_CRACK)
- {
- /*
- Content doesn't change.
-
- face_contents works just like it should, because
- there should not be faces between differently cracked
- nodes.
-
- If a semi-transparent node is cracked in front an
- another one, it really doesn't matter whether there
- is a cracked face drawn in between or not.
- */
- }
- }
-
- return mn.d;
-}
-
-v3s16 dirs8[8] = {
- v3s16(0,0,0),
- v3s16(0,0,1),
- v3s16(0,1,0),
- v3s16(0,1,1),
- v3s16(1,0,0),
- v3s16(1,1,0),
- v3s16(1,0,1),
- v3s16(1,1,1),
-};
-
-// Calculate lighting at the XYZ- corner of p
-u8 getSmoothLight(v3s16 p, VoxelManipulator &vmanip, u32 daynight_ratio)
-{
- u16 ambient_occlusion = 0;
- u16 light = 0;
- u16 light_count = 0;
- for(u32 i=0; i<8; i++)
- {
- MapNode n = vmanip.getNodeNoEx(p - dirs8[i]);
- if(content_features(n.d).param_type == CPT_LIGHT)
- {
- light += decode_light(n.getLightBlend(daynight_ratio));
- light_count++;
- }
- else
- {
- if(n.d != CONTENT_IGNORE)
- ambient_occlusion++;
- }
- }
-
- if(light_count == 0)
- return 255;
-
- light /= light_count;
-
- if(ambient_occlusion > 4)
- {
- ambient_occlusion -= 4;
- light = (float)light / ((float)ambient_occlusion * 0.5 + 1.0);
- }
-
- return light;
-}
-
-// Calculate lighting at the given corner of p
-u8 getSmoothLight(v3s16 p, v3s16 corner,
- VoxelManipulator &vmanip, u32 daynight_ratio)
-{
- if(corner.X == 1) p.X += 1;
- else assert(corner.X == -1);
- if(corner.Y == 1) p.Y += 1;
- else assert(corner.Y == -1);
- if(corner.Z == 1) p.Z += 1;
- else assert(corner.Z == -1);
-
- return getSmoothLight(p, vmanip, daynight_ratio);
-}
-
-/*
- 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 updateFastFaceRow(
- u32 daynight_ratio,
- v3f posRelative_f,
- v3s16 startpos,
- u16 length,
- v3s16 translate_dir,
- v3f translate_dir_f,
- v3s16 face_dir,
- v3f face_dir_f,
- core::array<FastFace> &dest,
- NodeModMap &temp_mods,
- VoxelManipulator &vmanip,
- v3s16 blockpos_nodes,
- bool smooth_lighting)
-{
- v3s16 p = startpos;
-
- u16 continuous_tiles_count = 0;
-
- MapNode n0 = vmanip.getNodeNoEx(blockpos_nodes + p);
- MapNode n1 = vmanip.getNodeNoEx(blockpos_nodes + p + face_dir);
- TileSpec tile0 = getNodeTile(n0, p, face_dir, temp_mods);
- TileSpec tile1 = getNodeTile(n1, p + face_dir, -face_dir, temp_mods);
- u8 light = getFaceLight(daynight_ratio, n0, n1, face_dir);
-
- for(u16 j=0; j<length; j++)
- {
- // If tiling can be done, this is set to false in the next step
- bool next_is_different = true;
-
- v3s16 p_next;
- MapNode n0_next;
- MapNode n1_next;
- TileSpec tile0_next;
- TileSpec tile1_next;
- u8 light_next = 0;
-
- // If at last position, there is nothing to compare to and
- // the face must be drawn anyway
- if(j != length - 1)
- {
- p_next = p + translate_dir;
-
- n0_next = vmanip.getNodeNoEx(blockpos_nodes + p_next);
- n1_next = vmanip.getNodeNoEx(blockpos_nodes + p_next + face_dir);
- tile0_next = getNodeTile(n0_next, p_next, face_dir, temp_mods);
- tile1_next = getNodeTile(n1_next,p_next+face_dir,-face_dir, temp_mods);
- light_next = getFaceLight(daynight_ratio, n0_next, n1_next, face_dir);
-
- if(tile0_next == tile0
- && tile1_next == tile1
- && light_next == light)
- {
- next_is_different = false;
- }
- }
-
- continuous_tiles_count++;
-
- // This is set to true if the texture doesn't allow more tiling
- bool end_of_texture = false;
- /*
- If there is no texture, it can be tiled infinitely.
- If tiled==0, it means the texture can be tiled infinitely.
- Otherwise check tiled agains continuous_tiles_count.
-
- This check has to be made for both tiles, because this is
- a bit hackish and we know which one we're using only when
- the decision to make the faces is made.
- */
- if(tile0.texture.atlas != NULL && tile0.texture.tiled != 0)
- {
- if(tile0.texture.tiled <= continuous_tiles_count)
- end_of_texture = true;
- }
- if(tile1.texture.atlas != NULL && tile1.texture.tiled != 0)
- {
- if(tile1.texture.tiled <= continuous_tiles_count)
- end_of_texture = true;
- }
-
- // Do this to disable tiling textures
- //end_of_texture = true; //DEBUG
-
- // Disable tiling of textures if smooth lighting is used
- if(smooth_lighting)
- end_of_texture = true;
-
- if(next_is_different || end_of_texture)
- {
- /*
- Create a face if there should be one
- */
- // This is hackish
- u8 content0 = getNodeContent(p, n0, temp_mods);
- u8 content1 = getNodeContent(p + face_dir, n1, temp_mods);
- u8 mf = face_contents(content0, content1);
-
- 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);
- u8 li0=255, li1=255, li2=255, li3=255;
-
- // First node
- v3s16 p_first = p - (continuous_tiles_count-1) * translate_dir;
-
- 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;
- }
-
-#if 1
- v3s16 p_map_leftmost;
- v3s16 p_map_rightmost;
- v3s16 face_dir_corrected;
- TileSpec tile;
-
- if(mf == 1)
- {
- tile = tile0;
- face_dir_corrected = face_dir;
- p_map_leftmost = p + blockpos_nodes;
- p_map_rightmost = p_first + blockpos_nodes;
- }
- else
- {
- // Offset to the actual solid block
- p_map_leftmost = p + blockpos_nodes + face_dir;
- p_map_rightmost = p_first + blockpos_nodes + face_dir;
- /*if(face_dir == v3s16(0,0,1))
- {
- v3s16 orig_leftmost = p_map_leftmost;
- v3s16 orig_rightmost = p_map_leftmost;
- p_map_leftmost = orig_rightmost;
- p_map_rightmost = orig_leftmost;
- }*/
- sp += face_dir_f;
- face_dir_corrected = -face_dir;
- tile = tile1;
- }
-
- if(smooth_lighting == false)
- {
- li0 = li1 = li2 = li3 = decode_light(light);
- }
- else
- {
- v3s16 vertex_dirs[4];
- getNodeVertexDirs(face_dir_corrected, vertex_dirs);
-
- li0 = getSmoothLight(p_map_rightmost, vertex_dirs[0],
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map_leftmost, vertex_dirs[1],
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map_leftmost, vertex_dirs[2],
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map_rightmost, vertex_dirs[3],
- vmanip, daynight_ratio);
- }
-
- makeFastFace(tile, li0, li1, li2, li3,
- sp, face_dir_corrected, scale,
- posRelative_f, dest);
-#else
- v3s16 p_map = p + blockpos_nodes;
- v3s16 p_map_first = p_first + blockpos_nodes;
-
- // If node at sp (tile0) is more solid
- if(mf == 1)
- {
- if(smooth_lighting)
- {
- if(face_dir == v3s16(0,0,1))
- {
- // Going along X+, faces in Z+
- li0 = getSmoothLight(p_map_first, v3s16(-1,-1,1),
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map, v3s16(1,-1,1),
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map, v3s16(1,1,1),
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map_first, v3s16(-1,1,1),
- vmanip, daynight_ratio);
- }
- else if(face_dir == v3s16(0,1,0))
- {
- // Going along X+, faces in Y+
- li0 = getSmoothLight(p_map_first, v3s16( 1,1,-1),
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map, v3s16(-1,1,-1),
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map, v3s16(-1,1,1),
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map_first, v3s16( 1,1,1),
- vmanip, daynight_ratio);
- }
- else if(face_dir == v3s16(1,0,0))
- {
- // Going along Z+, faces in X+
- li0 = getSmoothLight(p_map_first, v3s16(1,-1,1),
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map, v3s16(1,-1,-1),
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map, v3s16(1,1,-1),
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map_first, v3s16(1,1,1),
- vmanip, daynight_ratio);
- }
- else assert(0);
- }
-
- makeFastFace(tile0, li0, li1, li2, li3,
- sp, face_dir, scale,
- posRelative_f, dest);
- }
- // If node at sp is less solid (mf == 2)
- else
- {
- if(smooth_lighting)
- {
- // Offset to the actual solid block
- p_map += face_dir;
- p_map_first += face_dir;
-
- if(face_dir == v3s16(0,0,1))
- {
- // Going along X+, faces in Z-
- li0 = getSmoothLight(p_map, v3s16(1,-1,-1),
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map_first, v3s16(-1,-1,-1),
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map_first, v3s16(-1,1,-1),
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map, v3s16(1,1,-1),
- vmanip, daynight_ratio);
- }
- else if(face_dir == v3s16(0,1,0))
- {
- // Going along X+, faces in Y-
- li0 = getSmoothLight(p_map_first, v3s16(-1,-1,1),
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map, v3s16(1,-1,1),
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map, v3s16(1,-1,-1),
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map_first, v3s16(-1,-1,-1),
- vmanip, daynight_ratio);
- }
- else if(face_dir == v3s16(1,0,0))
- {
- // Going along Z+, faces in X-
- li0 = getSmoothLight(p_map_first, v3s16(-1,-1,-1),
- vmanip, daynight_ratio);
- li1 = getSmoothLight(p_map, v3s16(-1,-1,1),
- vmanip, daynight_ratio);
- li2 = getSmoothLight(p_map, v3s16(-1,1,1),
- vmanip, daynight_ratio);
- li3 = getSmoothLight(p_map_first, v3s16(-1,1,-1),
- vmanip, daynight_ratio);
- }
- else assert(0);
- }
-
- makeFastFace(tile1, li0, li1, li2, li3,
- sp+face_dir_f, -face_dir, scale,
- posRelative_f, dest);
- }
-#endif
- }
-
- continuous_tiles_count = 0;
- n0 = n0_next;
- n1 = n1_next;
- tile0 = tile0_next;
- tile1 = tile1_next;
- light = light_next;
- }
-
- p = p_next;
- }
-}
-
-/*
- This is used because CMeshBuffer::append() is very slow
-*/
-struct PreMeshBuffer
-{
- video::SMaterial material;
- core::array<u16> indices;
- core::array<video::S3DVertex> vertices;
-};
-
-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;
-
- p = &pp;
- break;
- }
-
- if(p == NULL)
- {
- PreMeshBuffer pp;
- pp.material = material;
- m_prebuffers.push_back(pp);
- p = &m_prebuffers[m_prebuffers.size()-1];
- }
-
- 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);
- }
- for(u32 i=0; i<numVertices; i++)
- {
- p->vertices.push_back(vertices[i]);
- }
- }
-
- 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());
- }
- }
-
-private:
- core::array<PreMeshBuffer> m_prebuffers;
-};
-
-scene::SMesh* makeMapBlockMesh(MeshMakeData *data)
-{
- // 4-21ms for MAP_BLOCKSIZE=16
- // 24-155ms for MAP_BLOCKSIZE=32
- //TimeTaker timer1("makeMapBlockMesh()");
-
- core::array<FastFace> fastfaces_new;
-
- v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE;
-
- // floating point conversion
- v3f posRelative_f(blockpos_nodes.X, blockpos_nodes.Y, blockpos_nodes.Z);
-
- /*
- Some settings
- */
- bool new_style_water = g_settings.getBool("new_style_water");
- bool new_style_leaves = g_settings.getBool("new_style_leaves");
- bool smooth_lighting = g_settings.getBool("smooth_lighting");
-
- float node_water_level = 1.0;
- if(new_style_water)
- node_water_level = 0.85;
-
- /*
- 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.
-
- NOTE: This is the slowest part of this method.
- */
-
- {
- // 4-23ms for MAP_BLOCKSIZE=16
- //TimeTaker timer2("updateMesh() collect");
-
- /*
- Go through every y,z and get top(y+) faces in rows of x+
- */
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- for(s16 z=0; z<MAP_BLOCKSIZE; z++){
- updateFastFaceRow(data->m_daynight_ratio, posRelative_f,
- v3s16(0,y,z), MAP_BLOCKSIZE,
- v3s16(1,0,0), //dir
- v3f (1,0,0),
- v3s16(0,1,0), //face dir
- v3f (0,1,0),
- fastfaces_new,
- data->m_temp_mods,
- data->m_vmanip,
- blockpos_nodes,
- smooth_lighting);
- }
- }
- /*
- Go through every x,y and get right(x+) faces in rows of z+
- */
- for(s16 x=0; x<MAP_BLOCKSIZE; x++){
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- updateFastFaceRow(data->m_daynight_ratio, posRelative_f,
- v3s16(x,y,0), MAP_BLOCKSIZE,
- v3s16(0,0,1),
- v3f (0,0,1),
- v3s16(1,0,0),
- v3f (1,0,0),
- fastfaces_new,
- data->m_temp_mods,
- data->m_vmanip,
- blockpos_nodes,
- smooth_lighting);
- }
- }
- /*
- Go through every y,z and get back(z+) faces in rows of x+
- */
- for(s16 z=0; z<MAP_BLOCKSIZE; z++){
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- updateFastFaceRow(data->m_daynight_ratio, posRelative_f,
- v3s16(0,y,z), MAP_BLOCKSIZE,
- v3s16(1,0,0),
- v3f (1,0,0),
- v3s16(0,0,1),
- v3f (0,0,1),
- fastfaces_new,
- data->m_temp_mods,
- data->m_vmanip,
- blockpos_nodes,
- smooth_lighting);
- }
- }
- }
-
- // End of slow part
-
- /*
- Convert FastFaces to SMesh
- */
-
- MeshCollector collector;
-
- if(fastfaces_new.size() > 0)
- {
- // avg 0ms (100ms spikes when loading textures the first time)
- //TimeTaker timer2("updateMesh() mesh building");
-
- video::SMaterial material;
- material.setFlag(video::EMF_LIGHTING, false);
- material.setFlag(video::EMF_BILINEAR_FILTER, false);
- material.setFlag(video::EMF_FOG_ENABLE, true);
- //material.setFlag(video::EMF_ANTI_ALIASING, video::EAAM_OFF);
- //material.setFlag(video::EMF_ANTI_ALIASING, video::EAAM_SIMPLE);
-
- for(u32 i=0; i<fastfaces_new.size(); i++)
- {
- FastFace &f = fastfaces_new[i];
-
- const u16 indices[] = {0,1,2,2,3,0};
-
- video::ITexture *texture = f.tile.texture.atlas;
- if(texture == NULL)
- continue;
-
- material.setTexture(0, texture);
-
- f.tile.applyMaterialOptions(material);
-
- collector.append(material, f.vertices, 4, indices, 6);
- }
- }
-
- /*
- Add special graphics:
- - torches
- - flowing water
- */
-
- // 0ms
- //TimeTaker timer2("updateMesh() adding special stuff");
-
- // Flowing water material
- video::SMaterial material_water1;
- material_water1.setFlag(video::EMF_LIGHTING, false);
- material_water1.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material_water1.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_water1.setFlag(video::EMF_FOG_ENABLE, true);
- material_water1.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
- AtlasPointer pa_water1 = g_texturesource->getTexture(
- g_texturesource->getTextureId("water.png"));
- material_water1.setTexture(0, pa_water1.atlas);
-
- // New-style leaves material
- video::SMaterial material_leaves1;
- material_leaves1.setFlag(video::EMF_LIGHTING, false);
- //material_leaves1.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material_leaves1.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_leaves1.setFlag(video::EMF_FOG_ENABLE, true);
- material_leaves1.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_leaves1 = g_texturesource->getTexture(
- g_texturesource->getTextureId("leaves.png"));
- material_leaves1.setTexture(0, pa_leaves1.atlas);
-
- 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 = data->m_vmanip.getNodeNoEx(blockpos_nodes+p);
-
- /*
- Add torches to mesh
- */
- if(n.d == CONTENT_TORCH)
- {
- video::SColor c(255,255,255,255);
-
- // Wall at X+ of node
- 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),
- };
-
- v3s16 dir = unpackDir(n.dir);
-
- 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 + blockpos_nodes, BS);
- }
-
- // Set material
- video::SMaterial material;
- material.setFlag(video::EMF_LIGHTING, false);
- material.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material.setFlag(video::EMF_BILINEAR_FILTER, false);
- //material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- material.MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
-
- if(dir == v3s16(0,-1,0))
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch_on_floor.png"));
- else if(dir == v3s16(0,1,0))
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch_on_ceiling.png"));
- // For backwards compatibility
- else if(dir == v3s16(0,0,0))
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch_on_floor.png"));
- else
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch.png"));
-
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material, vertices, 4, indices, 6);
- }
- /*
- Signs on walls
- */
- if(n.d == CONTENT_SIGN_WALL)
- {
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
- video::SColor c(255,l,l,l);
-
- float d = (float)BS/16;
- // Wall at X+ of node
- video::S3DVertex vertices[4] =
- {
- video::S3DVertex(BS/2-d,-BS/2,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2-d,-BS/2,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2-d,BS/2,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(BS/2-d,BS/2,-BS/2, 0,0,0, c, 0,0),
- };
-
- v3s16 dir = unpackDir(n.dir);
-
- 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.rotateXYBy(-90);
- if(dir == v3s16(0,1,0))
- vertices[i].Pos.rotateXYBy(90);
-
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
- }
-
- // Set material
- video::SMaterial material;
- material.setFlag(video::EMF_LIGHTING, false);
- material.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material.setFlag(video::EMF_BILINEAR_FILTER, false);
- material.setFlag(video::EMF_FOG_ENABLE, true);
- //material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- material.MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
-
- material.setTexture(0,
- g_texturesource->getTextureRaw("sign_wall.png"));
-
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material, vertices, 4, indices, 6);
- }
- /*
- Add flowing water to mesh
- */
- else if(n.d == CONTENT_WATER)
- {
- bool top_is_water = false;
- MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
- if(ntop.d == CONTENT_WATER || ntop.d == CONTENT_WATERSOURCE)
- top_is_water = true;
-
- u8 l = 0;
- // Use the light of the node on top if possible
- if(content_features(ntop.d).param_type == CPT_LIGHT)
- l = decode_light(ntop.getLightBlend(data->m_daynight_ratio));
- // Otherwise use the light of this node (the water)
- else
- l = decode_light(n.getLightBlend(data->m_daynight_ratio));
- video::SColor c(WATER_ALPHA,l,l,l);
-
- // Neighbor water levels (key = relative position)
- // Includes current node
- core::map<v3s16, f32> neighbor_levels;
- core::map<v3s16, u8> neighbor_contents;
- core::map<v3s16, u8> neighbor_flags;
- const u8 neighborflag_top_is_water = 0x01;
- v3s16 neighbor_dirs[9] = {
- v3s16(0,0,0),
- v3s16(0,0,1),
- v3s16(0,0,-1),
- v3s16(1,0,0),
- v3s16(-1,0,0),
- v3s16(1,0,1),
- v3s16(-1,0,-1),
- v3s16(1,0,-1),
- v3s16(-1,0,1),
- };
- for(u32 i=0; i<9; i++)
- {
- u8 content = CONTENT_AIR;
- float level = -0.5 * BS;
- u8 flags = 0;
- // Check neighbor
- v3s16 p2 = p + neighbor_dirs[i];
- MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
- if(n2.d != CONTENT_IGNORE)
- {
- content = n2.d;
-
- if(n2.d == CONTENT_WATERSOURCE)
- level = (-0.5+node_water_level) * BS;
- else if(n2.d == CONTENT_WATER)
- level = (-0.5 + ((float)n2.param2 + 0.5) / 8.0
- * node_water_level) * BS;
-
- // Check node above neighbor.
- // NOTE: This doesn't get executed if neighbor
- // doesn't exist
- p2.Y += 1;
- n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
- if(n2.d == CONTENT_WATERSOURCE || n2.d == CONTENT_WATER)
- flags |= neighborflag_top_is_water;
- }
-
- neighbor_levels.insert(neighbor_dirs[i], level);
- neighbor_contents.insert(neighbor_dirs[i], content);
- neighbor_flags.insert(neighbor_dirs[i], flags);
- }
-
- //float water_level = (-0.5 + ((float)n.param2 + 0.5) / 8.0) * BS;
- //float water_level = neighbor_levels[v3s16(0,0,0)];
-
- // Corner heights (average between four waters)
- f32 corner_levels[4];
-
- v3s16 halfdirs[4] = {
- v3s16(0,0,0),
- v3s16(1,0,0),
- v3s16(1,0,1),
- v3s16(0,0,1),
- };
- for(u32 i=0; i<4; i++)
- {
- v3s16 cornerdir = halfdirs[i];
- float cornerlevel = 0;
- u32 valid_count = 0;
- for(u32 j=0; j<4; j++)
- {
- v3s16 neighbordir = cornerdir - halfdirs[j];
- u8 content = neighbor_contents[neighbordir];
- // Special case for source nodes
- if(content == CONTENT_WATERSOURCE)
- {
- cornerlevel = (-0.5+node_water_level)*BS;
- valid_count = 1;
- break;
- }
- else if(content == CONTENT_WATER)
- {
- cornerlevel += neighbor_levels[neighbordir];
- valid_count++;
- }
- else if(content == CONTENT_AIR)
- {
- cornerlevel += -0.5*BS;
- valid_count++;
- }
- }
- if(valid_count > 0)
- cornerlevel /= valid_count;
- corner_levels[i] = cornerlevel;
- }
-
- /*
- Generate sides
- */
-
- v3s16 side_dirs[4] = {
- v3s16(1,0,0),
- v3s16(-1,0,0),
- v3s16(0,0,1),
- v3s16(0,0,-1),
- };
- s16 side_corners[4][2] = {
- {1, 2},
- {3, 0},
- {2, 3},
- {0, 1},
- };
- for(u32 i=0; i<4; i++)
- {
- v3s16 dir = side_dirs[i];
-
- /*
- If our topside is water and neighbor's topside
- is water, don't draw side face
- */
- if(top_is_water &&
- neighbor_flags[dir] & neighborflag_top_is_water)
- continue;
-
- u8 neighbor_content = neighbor_contents[dir];
-
- // Don't draw face if neighbor is not air or water
- if(neighbor_content != CONTENT_AIR
- && neighbor_content != CONTENT_WATER)
- continue;
-
- bool neighbor_is_water = (neighbor_content == CONTENT_WATER);
-
- // Don't draw any faces if neighbor is water and top is water
- if(neighbor_is_water == true && top_is_water == false)
- continue;
-
- video::S3DVertex vertices[4] =
- {
- /*video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x0(), pa_water1.y1()),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x1(), pa_water1.y1()),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x1(), pa_water1.y0()),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x0(), pa_water1.y0()),
- };
-
- /*
- If our topside is water, set upper border of face
- at upper border of node
- */
- if(top_is_water)
- {
- vertices[2].Pos.Y = 0.5*BS;
- vertices[3].Pos.Y = 0.5*BS;
- }
- /*
- Otherwise upper position of face is corner levels
- */
- else
- {
- vertices[2].Pos.Y = corner_levels[side_corners[i][0]];
- vertices[3].Pos.Y = corner_levels[side_corners[i][1]];
- }
-
- /*
- If neighbor is water, lower border of face is corner
- water levels
- */
- if(neighbor_is_water)
- {
- vertices[0].Pos.Y = corner_levels[side_corners[i][1]];
- vertices[1].Pos.Y = corner_levels[side_corners[i][0]];
- }
- /*
- If neighbor is not water, lower border of face is
- lower border of node
- */
- else
- {
- vertices[0].Pos.Y = -0.5*BS;
- vertices[1].Pos.Y = -0.5*BS;
- }
-
- for(s32 j=0; j<4; j++)
- {
- if(dir == v3s16(0,0,1))
- vertices[j].Pos.rotateXZBy(0);
- if(dir == v3s16(0,0,-1))
- vertices[j].Pos.rotateXZBy(180);
- if(dir == v3s16(-1,0,0))
- vertices[j].Pos.rotateXZBy(90);
- if(dir == v3s16(1,0,-0))
- vertices[j].Pos.rotateXZBy(-90);
-
- vertices[j].Pos += intToFloat(p + blockpos_nodes, BS);
- }
-
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material_water1, vertices, 4, indices, 6);
- }
-
- /*
- Generate top side, if appropriate
- */
-
- if(top_is_water == false)
- {
- video::S3DVertex vertices[4] =
- {
- /*video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x0(), pa_water1.y1()),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x1(), pa_water1.y1()),
- video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c,
- pa_water1.x1(), pa_water1.y0()),
- video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c,
- pa_water1.x0(), pa_water1.y0()),
- };
-
- // This fixes a strange bug
- s32 corner_resolve[4] = {3,2,1,0};
-
- for(s32 i=0; i<4; i++)
- {
- //vertices[i].Pos.Y += water_level;
- //vertices[i].Pos.Y += neighbor_levels[v3s16(0,0,0)];
- s32 j = corner_resolve[i];
- vertices[i].Pos.Y += corner_levels[j];
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
- }
-
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material_water1, vertices, 4, indices, 6);
- }
- }
- /*
- Add water sources to mesh if using new style
- */
- else if(n.d == CONTENT_WATERSOURCE && new_style_water)
- {
- //bool top_is_water = false;
- bool top_is_air = false;
- MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
- /*if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
- top_is_water = true;*/
- if(n.d == CONTENT_AIR)
- top_is_air = true;
-
- /*if(top_is_water == true)
- continue;*/
- if(top_is_air == false)
- continue;
-
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
- video::SColor c(WATER_ALPHA,l,l,l);
-
- video::S3DVertex vertices[4] =
- {
- /*video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x0(), pa_water1.y1()),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_water1.x1(), pa_water1.y1()),
- video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c,
- pa_water1.x1(), pa_water1.y0()),
- video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c,
- pa_water1.x0(), pa_water1.y0()),
- };
-
- for(s32 i=0; i<4; i++)
- {
- vertices[i].Pos.Y += (-0.5+node_water_level)*BS;
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
- }
-
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material_water1, vertices, 4, indices, 6);
- }
- /*
- Add leaves if using new style
- */
- else if(n.d == CONTENT_LEAVES && new_style_leaves)
- {
- /*u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));*/
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
- video::SColor c(255,l,l,l);
-
- for(u32 j=0; j<6; j++)
- {
- video::S3DVertex vertices[4] =
- {
- /*video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c, 0,0),*/
- video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x0(), pa_leaves1.y1()),
- video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x1(), pa_leaves1.y1()),
- video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x1(), pa_leaves1.y0()),
- video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x0(), pa_leaves1.y0()),
- };
-
- if(j == 0)
- {
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(0);
- }
- else if(j == 1)
- {
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(180);
- }
- else if(j == 2)
- {
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(-90);
- }
- else if(j == 3)
- {
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(90);
- }
- else if(j == 4)
- {
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateYZBy(-90);
- }
- else if(j == 5)
- {
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateYZBy(90);
- }
-
- for(u16 i=0; i<4; i++)
- {
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
- }
-
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material_leaves1, vertices, 4, indices, 6);
- }
- }
- }
-
- /*
- Add stuff from collector to mesh
- */
-
- scene::SMesh *mesh_new = NULL;
- mesh_new = new scene::SMesh();
-
- collector.fillMesh(mesh_new);
-
- /*
- Do some stuff to the mesh
- */
-
- mesh_new->recalculateBoundingBox();
-
- /*
- Delete new mesh if it is empty
- */
-
- if(mesh_new->getMeshBufferCount() == 0)
- {
- mesh_new->drop();
- mesh_new = NULL;
- }
-
- if(mesh_new)
- {
-#if 0
- // Usually 1-700 faces and 1-7 materials
- std::cout<<"Updated MapBlock has "<<fastfaces_new.size()<<" faces "
- <<"and uses "<<mesh_new->getMeshBufferCount()
- <<" materials (meshbuffers)"<<std::endl;
-#endif
-
- // Use VBO for mesh (this just would set this for ever buffer)
- // This will lead to infinite memory usage because or irrlicht.
- //mesh_new->setHardwareMappingHint(scene::EHM_STATIC);
-
- /*
- NOTE: If that is enabled, some kind of a queue to the main
- thread should be made which would call irrlicht to delete
- the hardware buffer and then delete the mesh
- */
- }
-
- return mesh_new;
-
- //std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
-}
-
-#endif // !SERVER
+#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
/*
MapBlock
*/
-MapBlock::MapBlock(NodeContainer *parent, v3s16 pos, bool dummy):
+MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
+ heat(0),
+ humidity(0),
+ weather_update_time(0),
m_parent(parent),
m_pos(pos),
- changed(true),
+ 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_not_fully_generated(false),
- m_objects(this)
+ 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)
{
data = NULL;
if(dummy == false)
reallocate();
- //m_spawn_timer = -10000;
-
#ifndef SERVER
- m_mesh_expired = false;
- mesh_mutex.Init();
+ //mesh_mutex.Init();
mesh = NULL;
- m_temp_mods_mutex.Init();
#endif
}
{
#ifndef SERVER
{
- JMutexAutoLock lock(mesh_mutex);
+ //JMutexAutoLock lock(mesh_mutex);
if(mesh)
{
- mesh->drop();
+ delete mesh;
mesh = NULL;
}
}
{
if(data == NULL)
{
- return MapNode(CONTENT_IGNORE);
- }
- return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
- }
-}
-
-#ifndef SERVER
-
-#if 1
-void MapBlock::updateMesh(u32 daynight_ratio)
-{
-#if 0
- /*
- DEBUG: If mesh has been generated, don't generate it again
- */
- {
- JMutexAutoLock meshlock(mesh_mutex);
- if(mesh != NULL)
- return;
- }
-#endif
-
- MeshMakeData data;
- data.fill(daynight_ratio, this);
-
- scene::SMesh *mesh_new = makeMapBlockMesh(&data);
-
- /*
- Replace the mesh
- */
-
- replaceMesh(mesh_new);
-
-}
-#endif
-
-void MapBlock::replaceMesh(scene::SMesh *mesh_new)
-{
- mesh_mutex.Lock();
-
- //scene::SMesh *mesh_old = mesh[daynight_i];
- //mesh[daynight_i] = mesh_new;
-
- scene::SMesh *mesh_old = mesh;
- mesh = mesh_new;
- setMeshExpired(false);
-
- if(mesh_old != NULL)
- {
- // 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);
- }*/
-
- /*dstream<<"mesh_old->getReferenceCount()="
- <<mesh_old->getReferenceCount()<<std::endl;
- u32 c = mesh_old->getMeshBufferCount();
- for(u32 i=0; i<c; i++)
- {
- scene::IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
- dstream<<"buf->getReferenceCount()="
- <<buf->getReferenceCount()<<std::endl;
- }*/
-
- // Drop the mesh
- mesh_old->drop();
-
- //delete mesh_old;
+ return MapNode(CONTENT_IGNORE);
+ }
+ return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
}
-
- mesh_mutex.Unlock();
}
-
-#endif // !SERVER
/*
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 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.
- At the moment, all sunlighted nodes are added to light_sources.
- - SUGG: This could be optimized
-
- Turns sunglighted mud into grass.
+ 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(core::map<v3s16, bool> & light_sources,
- bool remove_light, bool *black_air_left,
- bool grow_grass)
+bool MapBlock::propagateSunlight(std::set<v3s16> & 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;
// Check if node above block has sunlight
try{
MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
- if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
+ if(n.getContent() == CONTENT_IGNORE)
+ {
+ // Trust heuristics
+ no_sunlight = is_underground;
+ }
+ else if(n.getLight(LIGHTBANK_DAY, m_gamedef->ndef()) != LIGHT_SUN)
{
no_sunlight = true;
}
else
{
MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
- if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
+ if(m_gamedef->ndef()->get(n).sunlight_propagates == false)
{
no_sunlight = true;
}
{
// Do nothing
}
- else if(current_light == LIGHT_SUN && n.sunlight_propagates())
+ else if(current_light == LIGHT_SUN && nodemgr->get(n).sunlight_propagates)
{
// Do nothing: Sunlight is continued
}
- else if(n.light_propagates() == false)
+ else if(nodemgr->get(n).light_propagates == false)
{
- if(grow_grass)
- {
- bool upper_is_air = false;
- try
- {
- if(getNodeParent(pos+v3s16(0,1,0)).d == CONTENT_AIR)
- upper_is_air = true;
- }
- catch(InvalidPositionException &e)
- {
- }
- // Turn mud into grass
- if(upper_is_air && n.d == CONTENT_MUD
- && current_light == LIGHT_SUN)
- {
- n.d = CONTENT_GRASS;
- }
- }
-
// A solid object is on the way.
stopped_to_solid_object = true;
current_light = diminish_light(current_light);
}
- u8 old_light = n.getLight(LIGHTBANK_DAY);
+ u8 old_light = n.getLight(LIGHTBANK_DAY, nodemgr);
if(current_light > old_light || remove_light)
{
- n.setLight(LIGHTBANK_DAY, current_light);
+ n.setLight(LIGHTBANK_DAY, current_light, nodemgr);
}
if(diminish_light(current_light) != 0)
{
- light_sources.insert(pos_relative + pos, true);
+ light_sources.insert(pos_relative + pos);
}
if(current_light == 0 && stopped_to_solid_object)
if(block_below_is_valid)
{
MapNode n = getNodeParent(v3s16(x, -1, z));
- if(n.light_propagates())
+ if(nodemgr->get(n).light_propagates)
{
- if(n.getLight(LIGHTBANK_DAY) == LIGHT_SUN
+ if(n.getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN
&& sunlight_should_go_down == false)
block_below_is_valid = false;
- else if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN
+ else if(n.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN
&& sunlight_should_go_down == true)
block_below_is_valid = false;
}
getPosRelative(), data_size);
}
-void MapBlock::stepObjects(float dtime, bool server, u32 daynight_ratio)
+void MapBlock::actuallyUpdateDayNightDiff()
{
- /*
- Step objects
- */
- m_objects.step(dtime, server, daynight_ratio);
-
-#if 0
- /*
- Spawn some objects at random.
-
- Use dayNightDiffed() to approximate being near ground level
- */
- if(m_spawn_timer < -999)
- {
- m_spawn_timer = 60;
- }
- if(dayNightDiffed() == true && getObjectCount() == 0)
- {
- m_spawn_timer -= dtime;
- if(m_spawn_timer <= 0.0)
- {
- m_spawn_timer += myrand() % 300;
-
- v2s16 p2d(
- (myrand()%(MAP_BLOCKSIZE-1))+0,
- (myrand()%(MAP_BLOCKSIZE-1))+0
- );
-
- s16 y = getGroundLevel(p2d);
-
- if(y >= 0)
- {
- v3s16 p(p2d.X, y+1, p2d.Y);
-
- if(getNode(p).d == CONTENT_AIR
- && getNode(p).getLightBlend(daynight_ratio) <= 11)
- {
- RatObject *obj = new RatObject(NULL, -1, intToFloat(p, BS));
- addObject(obj);
- }
- }
- }
- }
-#endif
-
- setChangedFlag();
-}
-
+ INodeDefManager *nodemgr = m_gamedef->ndef();
+ // Running this function un-expires m_day_night_differs
+ m_day_night_differs_expired = false;
-void MapBlock::updateDayNightDiff()
-{
if(data == NULL)
{
m_day_night_differs = false;
for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
{
MapNode &n = data[i];
- if(n.getLight(LIGHTBANK_DAY) != n.getLight(LIGHTBANK_NIGHT))
+ if(n.getLight(LIGHTBANK_DAY, nodemgr) != n.getLight(LIGHTBANK_NIGHT, nodemgr))
{
differs = true;
break;
for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
{
MapNode &n = data[i];
- if(n.d != CONTENT_AIR)
+ if(n.getContent() != CONTENT_AIR)
{
only_air = false;
break;
m_day_night_differs = differs;
}
+void MapBlock::expireDayNightDiff()
+{
+ //INodeDefManager *nodemgr = m_gamedef->ndef();
+
+ if(data == NULL){
+ 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())
s16 y = MAP_BLOCKSIZE-1;
for(; y>=0; y--)
{
- //if(is_ground_content(getNodeRef(p2d.X, y, p2d.Y).d))
- if(content_features(getNodeRef(p2d.X, y, p2d.Y).d).walkable)
+ MapNode n = getNodeRef(p2d.X, y, p2d.Y);
+ if(m_gamedef->ndef()->get(n).walkable)
{
if(y == MAP_BLOCKSIZE-1)
return -2;
/*
Serialization
*/
+// List relevant id-name pairs for ids in the block using nodedef
+// Renumbers the content IDs (starting at 0 and incrementing
+static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
+ INodeDefManager *nodedef)
+{
+ std::map<content_t, content_t> mapping;
+ std::set<content_t> unknown_contents;
+ content_t id_counter = 0;
+ for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
+ {
+ content_t global_id = nodes[i].getContent();
+ content_t id = CONTENT_IGNORE;
+
+ // Try to find an existing mapping
+ std::map<content_t, content_t>::iterator j = mapping.find(global_id);
+ if(j != mapping.end())
+ {
+ id = j->second;
+ }
+ else
+ {
+ // We have to assign a new mapping
+ id = id_counter++;
+ mapping.insert(std::make_pair(global_id, id));
+
+ const ContentFeatures &f = nodedef->get(global_id);
+ const std::string &name = f.name;
+ if(name == "")
+ unknown_contents.insert(global_id);
+ else
+ nimap->set(id, name);
+ }
+
+ // Update the MapNode
+ nodes[i].setContent(id);
+ }
+ for(std::set<content_t>::const_iterator
+ i = unknown_contents.begin();
+ i != unknown_contents.end(); i++){
+ errorstream<<"getBlockNodeIdMapping(): IGNORING ERROR: "
+ <<"Name for node id "<<(*i)<<" 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::set<content_t> unnamed_contents;
+ std::set<std::string> unallocatable_contents;
+ for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
+ {
+ content_t local_id = nodes[i].getContent();
+ std::string name;
+ bool found = nimap->getName(local_id, name);
+ if(!found){
+ unnamed_contents.insert(local_id);
+ continue;
+ }
+ content_t global_id;
+ found = nodedef->getId(name, global_id);
+ if(!found){
+ global_id = gamedef->allocateUnknownNodeId(name);
+ if(global_id == CONTENT_IGNORE){
+ unallocatable_contents.insert(name);
+ continue;
+ }
+ }
+ nodes[i].setContent(global_id);
+ }
+ for(std::set<content_t>::const_iterator
+ i = unnamed_contents.begin();
+ i != unnamed_contents.end(); i++){
+ errorstream<<"correctBlockNodeIds(): IGNORING ERROR: "
+ <<"Block contains id "<<(*i)
+ <<" with no name mapping"<<std::endl;
+ }
+ for(std::set<std::string>::const_iterator
+ i = unallocatable_contents.begin();
+ i != unallocatable_contents.end(); i++){
+ errorstream<<"correctBlockNodeIds(): IGNORING ERROR: "
+ <<"Could not allocate global id for node name \""
+ <<(*i)<<"\""<<std::endl;
+ }
+}
-void MapBlock::serialize(std::ostream &os, u8 version)
+void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
{
if(!ser_ver_supported(version))
throw VersionMismatchException("ERROR: MapBlock format not supported");
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;
+ // Can't do this anymore; we have 16-bit dynamically allocated node IDs
+ // in memory; conversion just won't work in this direction.
+ if(version < 24)
+ throw SerializationError("MapBlock::serialize: serialization to "
+ "version < 24 not possible");
- u32 buflen = 1 + nodecount * MapNode::serializedLength(version);
- SharedBuffer<u8> dest(buflen);
-
- dest[0] = is_underground;
+ // First byte
+ u8 flags = 0;
+ if(is_underground)
+ flags |= 0x01;
+ if(getDayNightDiff())
+ flags |= 0x02;
+ if(m_lighting_expired)
+ flags |= 0x04;
+ if(m_generated == false)
+ flags |= 0x08;
+ writeU8(os, flags);
+
+ /*
+ Bulk node data
+ */
+ NameIdMapping nimap;
+ u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+ if(disk)
+ {
+ MapNode *tmp_nodes = new MapNode[nodecount];
for(u32 i=0; i<nodecount; i++)
- {
- u32 s = 1 + i * MapNode::serializedLength(version);
- data[i].serialize(&dest[s], version);
- }
-
- os.write((char*)*dest, dest.getSize());
+ 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 if(version <= 10)
+ 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;
+ 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);
+ }
+
+ /*
+ Node metadata
+ */
+ std::ostringstream oss(std::ios_base::binary);
+ m_node_metadata.serialize(oss);
+ compressZlib(oss.str(), os);
- // Get and compress materials
- SharedBuffer<u8> materialdata(nodecount);
- for(u32 i=0; i<nodecount; i++)
- {
- materialdata[i] = data[i].d;
+ /*
+ Data that goes to disk, but not the network
+ */
+ if(disk)
+ {
+ if(version <= 24){
+ // Node timers
+ m_node_timers.serialize(os, version);
}
- compress(materialdata, os, version);
- // Get and compress lights
- SharedBuffer<u8> lightdata(nodecount);
- for(u32 i=0; i<nodecount; i++)
- {
- lightdata[i] = data[i].param;
- }
- compress(lightdata, os, version);
+ // Static objects
+ m_static_objects.serialize(os);
+
+ // Timestamp
+ writeU32(os, getTimestamp());
+
+ // Write block-specific node definition id mapping
+ nimap.serialize(os);
- if(version >= 10)
- {
- // Get and compress param2
- SharedBuffer<u8> param2data(nodecount);
- for(u32 i=0; i<nodecount; i++)
- {
- param2data[i] = data[i].param2;
- }
- compress(param2data, os, version);
+ if(version >= 25){
+ // Node timers
+ m_node_timers.serialize(os, version);
}
}
- // All other versions (newest)
- else
+}
+
+void MapBlock::serializeNetworkSpecific(std::ostream &os, u16 net_proto_version)
+{
+ if(data == NULL)
{
- // First byte
- u8 flags = 0;
- if(is_underground)
- flags |= 0x01;
- if(m_day_night_differs)
- flags |= 0x02;
- if(m_lighting_expired)
- flags |= 0x04;
- os.write((char*)&flags, 1);
-
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+ throw SerializationError("ERROR: Not writing dummy block.");
+ }
- /*
- Get data
- */
+ if(net_proto_version >= 21){
+ int version = 1;
+ writeU8(os, version);
+ writeF1000(os, heat);
+ writeF1000(os, humidity);
+ }
+}
- SharedBuffer<u8> databuf(nodecount*3);
+void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
+{
+ if(!ser_ver_supported(version))
+ throw VersionMismatchException("ERROR: MapBlock format not supported");
+
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())<<std::endl);
- // Get contents
- for(u32 i=0; i<nodecount; i++)
- {
- databuf[i] = data[i].d;
- }
+ m_day_night_differs_expired = false;
- // Get params
- for(u32 i=0; i<nodecount; i++)
- {
- databuf[i+nodecount] = data[i].param;
- }
+ if(version <= 21)
+ {
+ deSerialize_pre22(is, version, disk);
+ return;
+ }
- // Get param2
- for(u32 i=0; i<nodecount; i++)
- {
- databuf[i+nodecount*2] = data[i].param2;
- }
+ 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;
- /*
- Compress data to output stream
- */
+ /*
+ Bulk node data
+ */
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Bulk node data"<<std::endl);
+ u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+ 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);
+
+ /*
+ NodeMetadata
+ */
+ 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);
+ else
+ content_nodemeta_deserialize_legacy(iss,
+ &m_node_metadata, &m_node_timers,
+ m_gamedef);
+ }
+ catch(SerializationError &e)
+ {
+ errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+ <<" while deserializing node metadata at ("
+ <<PP(getPos())<<": "<<e.what()<<std::endl;
+ }
+
+ /*
+ 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);
+ }
- compress(databuf, os, version);
+ // Static objects
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Static objects"<<std::endl);
+ m_static_objects.deSerialize(is);
- /*
- NodeMetadata
- */
- if(version >= 14)
- {
- if(version <= 15)
- {
- std::ostringstream oss(std::ios_base::binary);
- m_node_metadata.serialize(oss);
- os<<serializeString(oss.str());
- }
- else
- {
- std::ostringstream oss(std::ios_base::binary);
- m_node_metadata.serialize(oss);
- compressZlib(oss.str(), os);
- //os<<serializeLongString(oss.str());
- }
+ // 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);
}
}
+
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Done."<<std::endl);
}
-void MapBlock::deSerialize(std::istream &is, u8 version)
+void MapBlock::deSerializeNetworkSpecific(std::istream &is)
{
- if(!ser_ver_supported(version))
- throw VersionMismatchException("ERROR: MapBlock format not supported");
-
- // These have no lighting info
- if(version <= 1)
+ try {
+ int version = readU8(is);
+ //if(version != 1)
+ // throw SerializationError("unsupported MapBlock version");
+ if(version >= 1) {
+ heat = readF1000(is);
+ humidity = readF1000(is);
+ }
+ }
+ catch(SerializationError &e)
{
- setLightingExpired(true);
+ errorstream<<"WARNING: MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
+ <<": "<<e.what()<<std::endl;
}
+}
+
+/*
+ Legacy serialization
+*/
+
+void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
+{
+ u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+
+ // Initialize default flags
+ is_underground = false;
+ m_day_night_differs = false;
+ m_lighting_expired = false;
+ 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)
{
- 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);
- }
+ 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)
{
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
u8 t8;
is.read((char*)&t8, 1);
is_underground = t8;
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].d = s[i];
+ databuf_nodelist[i*ser_length] = s[i];
}
}
{
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param = s[i];
+ databuf_nodelist[i*ser_length + 1] = s[i];
}
}
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param2 = s[i];
+ databuf_nodelist[i*ser_length + 2] = s[i];
}
}
}
// All other versions (newest)
else
{
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
u8 flags;
is.read((char*)&flags, 1);
is_underground = (flags & 0x01) ? true : false;
m_day_night_differs = (flags & 0x02) ? true : false;
m_lighting_expired = (flags & 0x04) ? true : false;
+ if(version >= 18)
+ m_generated = (flags & 0x08) ? false : true;
// Uncompress data
std::ostringstream os(std::ios_base::binary);
std::string s = os.str();
if(s.size() != nodecount*3)
throw SerializationError
- ("MapBlock::deSerialize: invalid format");
+ ("MapBlock::deSerialize: decompress resulted in size"
+ " other than nodecount*3");
- // Set contents
- for(u32 i=0; i<nodecount; i++)
- {
- data[i].d = s[i];
- }
- // Set params
- for(u32 i=0; i<nodecount; i++)
- {
- data[i].param = s[i+nodecount];
- }
- // Set param2
+ // deserialize nodes from buffer
for(u32 i=0; i<nodecount; i++)
{
- data[i].param2 = s[i+nodecount*2];
+ 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];
}
/*
{
std::string data = deSerializeString(is);
std::istringstream iss(data, std::ios_base::binary);
- m_node_metadata.deSerialize(iss);
+ content_nodemeta_deserialize_legacy(iss,
+ &m_node_metadata, &m_node_timers,
+ m_gamedef);
}
else
{
std::ostringstream oss(std::ios_base::binary);
decompressZlib(is, oss);
std::istringstream iss(oss.str(), std::ios_base::binary);
- m_node_metadata.deSerialize(iss);
+ content_nodemeta_deserialize_legacy(iss,
+ &m_node_metadata, &m_node_timers,
+ m_gamedef);
}
}
catch(SerializationError &e)
{
- dstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+ errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
<<" while deserializing node metadata"<<std::endl;
}
}
}
+
+ // Deserialize node data
+ for(u32 i=0; i<nodecount; i++)
+ {
+ data[i].deSerialize(&databuf_nodelist[i*ser_length], version);
+ }
+
+ 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){
+ errorstream<<"WARNING: MapBlock::deSerialize_pre22(): "
+ <<"Ignoring stuff coming at and after MBOs"<<std::endl;
+ return;
+ }
+ }
+
+ /*
+ 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);
+ }
+
+ // 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);
+ }
+
+
+ // 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++)
+ {
+ const ContentFeatures &f = nodedef->get(data[i].getContent());
+ // Mineral
+ if(nodedef->getId("default:stone") == data[i].getContent()
+ && data[i].getParam1() == 1)
+ {
+ data[i].setContent(nodedef->getId("default:stone_with_coal"));
+ data[i].setParam1(0);
+ }
+ else if(nodedef->getId("default:stone") == data[i].getContent()
+ && data[i].getParam1() == 2)
+ {
+ data[i].setContent(nodedef->getId("default:stone_with_iron"));
+ data[i].setParam1(0);
+ }
+ // facedir_simple
+ if(f.legacy_facedir_simple)
+ {
+ data[i].setParam2(data[i].getParam1());
+ data[i].setParam1(0);
+ }
+ // wall_mounted
+ if(f.legacy_wallmounted)
+ {
+ 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++)
+ {
+ if((dir_old_format & wallmounted_new_to_old[j]) != 0)
+ {
+ dir_new_format = j;
+ break;
+ }
+ }
+ data[i].setParam2(dir_new_format);
+ }
+ }
+
+}
+
+/*
+ Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block)
+{
+ if(block == NULL)
+ return "NULL";
+
+ std::ostringstream desc;
- /*
- Translate nodes as specified in the translate_to fields of
- node features
- */
- for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
+ v3s16 p = block->getPos();
+ char spos[20];
+ snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
+ desc<<spos;
+
+ switch(block->getModified())
{
- MapNode &n = data[i];
+ 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())+", ";
+ }
+
+ if(block->isGenerated())
+ desc<<"is_gen [X], ";
+ else
+ desc<<"is_gen [ ], ";
+
+ if(block->getIsUnderground())
+ desc<<"is_ug [X], ";
+ else
+ desc<<"is_ug [ ], ";
+
+ if(block->getLightingExpired())
+ desc<<"lighting_exp [X], ";
+ else
+ desc<<"lighting_exp [ ], ";
- MapNode *translate_to = content_features(n.d).translate_to;
- if(translate_to)
+ 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++)
{
- dstream<<"MapBlock: WARNING: Translating node "<<n.d<<" to "
- <<translate_to->d<<std::endl;
- n = *translate_to;
+ v3s16 p(x0,y0,z0);
+ MapNode n = block->getNode(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);
}