MapBlockMesh, mesh animation system, urgent mesh updates, athmospheric light, removed footprints

1 files changed, 596 insertions, 372 deletions

diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp
index b843448c4..abe23855f 100644
--- a/src/mapblock_mesh.cpp
+++ b/src/mapblock_mesh.cpp
@@ -21,28 +21,32 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "light.h"
 #include "mapblock.h"
 #include "map.h"
-#include "main.h" // For g_settings and g_texturesource
-#include "settings.h"
+#include "main.h" // for g_profiler
 #include "profiler.h"
 #include "nodedef.h"
 #include "gamedef.h"
+#include "mesh.h"
 #include "content_mapblock.h"
 
-void MeshMakeData::fill(u32 daynight_ratio, MapBlock *block)
+/*
+	MeshMakeData
+*/
+
+MeshMakeData::MeshMakeData(IGameDef *gamedef):
+	m_vmanip(),
+	m_blockpos(-1337,-1337,-1337),
+	m_crack_pos_relative(-1337, -1337, -1337),
+	m_smooth_lighting(false),
+	m_gamedef(gamedef)
+{}
+
+void MeshMakeData::fill(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
 	*/
 
@@ -81,11 +85,9 @@ void MeshMakeData::fill(u32 daynight_ratio, MapBlock *block)
 	}
 }
 
-void MeshMakeData::fillSingleNode(u32 daynight_ratio, MapNode *node)
+void MeshMakeData::fillSingleNode(MapNode *node)
 {
-	m_daynight_ratio = daynight_ratio;
 	m_blockpos = v3s16(0,0,0);
-	m_temp_mods.clear();
 	
 	v3s16 blockpos_nodes = v3s16(0,0,0);
 	VoxelArea area(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE,
@@ -114,6 +116,226 @@ void MeshMakeData::fillSingleNode(u32 daynight_ratio, MapNode *node)
 	delete[] data;
 }
 
+void MeshMakeData::setCrack(int crack_level, v3s16 crack_pos)
+{
+	if(crack_level >= 0)
+		m_crack_pos_relative = crack_pos - m_blockpos*MAP_BLOCKSIZE;
+}
+
+void MeshMakeData::setSmoothLighting(bool smooth_lighting)
+{
+	m_smooth_lighting = smooth_lighting;
+}
+
+/*
+	Light and vertex color functions
+*/
+
+/*
+	Calculate non-smooth lighting at interior of node.
+	Single light bank.
+*/
+static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment,
+		MeshMakeData *data)
+{
+	INodeDefManager *ndef = data->m_gamedef->ndef();
+	u8 light = n.getLight(bank, ndef);
+
+	while(increment > 0)
+	{
+		light = undiminish_light(light);
+		--increment;
+	}
+	while(increment < 0)
+	{
+		light = diminish_light(light);
+		++increment;
+	}
+
+	return decode_light(light);
+}
+
+/*
+	Calculate non-smooth lighting at interior of node.
+	Both light banks.
+*/
+u16 getInteriorLight(MapNode n, s32 increment, MeshMakeData *data)
+{
+	u16 day = getInteriorLight(LIGHTBANK_DAY, n, increment, data);
+	u16 night = getInteriorLight(LIGHTBANK_NIGHT, n, increment, data);
+	return day | (night << 8);
+}
+
+/*
+	Calculate non-smooth lighting at face of node.
+	Single light bank.
+*/
+static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2,
+		v3s16 face_dir, MeshMakeData *data)
+{
+	INodeDefManager *ndef = data->m_gamedef->ndef();
+
+	u8 light;
+	u8 l1 = n.getLight(bank, ndef);
+	u8 l2 = n2.getLight(bank, ndef);
+	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 decode_light(light);
+}
+
+/*
+	Calculate non-smooth lighting at face of node.
+	Both light banks.
+*/
+u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, MeshMakeData *data)
+{
+	u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, face_dir, data);
+	u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, face_dir, data);
+	return day | (night << 8);
+}
+
+/*
+	Calculate smooth lighting at the XYZ- corner of p.
+	Single light bank.
+*/
+static u8 getSmoothLight(enum LightBank bank, v3s16 p, MeshMakeData *data)
+{
+	static 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),
+	};
+
+	INodeDefManager *ndef = data->m_gamedef->ndef();
+
+	u16 ambient_occlusion = 0;
+	u16 light = 0;
+	u16 light_count = 0;
+	for(u32 i=0; i<8; i++)
+	{
+		MapNode n = data->m_vmanip.getNodeNoEx(p - dirs8[i]);
+		const ContentFeatures &f = ndef->get(n);
+		// Check f.solidness because fast-style leaves look
+		// better this way
+		if(f.param_type == CPT_LIGHT && f.solidness != 2)
+		{
+			light += decode_light(n.getLight(bank, ndef));
+			light_count++;
+		}
+		else if(n.getContent() != 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 smooth lighting at the XYZ- corner of p.
+	Both light banks.
+*/
+static u16 getSmoothLight(v3s16 p, MeshMakeData *data)
+{
+	u16 day = getSmoothLight(LIGHTBANK_DAY, p, data);
+	u16 night = getSmoothLight(LIGHTBANK_NIGHT, p, data);
+	return day | (night << 8);
+}
+
+/*
+	Calculate smooth lighting at the given corner of p.
+	Both light banks.
+*/
+u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data)
+{
+	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, data);
+}
+
+/*
+	Converts from day + night color values (0..255)
+	and a given daynight_ratio to the final SColor shown on screen.
+*/
+static void finalColorBlend(video::SColor& result,
+		u8 day, u8 night, u32 daynight_ratio)
+{
+	s32 rg = (day * daynight_ratio + night * (1000-daynight_ratio)) / 1000;
+	s32 b = rg;
+
+	// Moonlight is blue
+	b += (day - night) / 13;
+	rg -= (day - night) / 23;
+
+	// Emphase blue a bit in darker places
+	// Each entry of this array represents a range of 8 blue levels
+	static u8 emphase_blue_when_dark[32] = {
+		1, 4, 6, 6, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	};
+	if(b < 0)
+		b = 0;
+	if(b > 255)
+		b = 255;
+	b += emphase_blue_when_dark[b / 8];
+
+	// Artificial light is yellow-ish
+	static u8 emphase_yellow_when_artificial[16] = {
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 10, 15, 15, 15
+	};
+	rg += emphase_yellow_when_artificial[night/16];
+	if(rg < 0)
+		rg = 0;
+	if(rg > 255)
+		rg = 255;
+
+	result.setRed(rg);
+	result.setGreen(rg);
+	result.setBlue(b);
+}
+
+/*
+	Mesh generation helpers
+*/
+
 /*
 	vertex_dirs: v3s16[4]
 */
@@ -177,41 +399,19 @@ static void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs)
 	}
 }
 
-video::SColor MapBlock_LightColor(u8 alpha, u8 light)
-{
-#if 0
-	return video::SColor(alpha,light,light,light);
-#endif
-	//return video::SColor(alpha,light,light,MYMAX(0, (s16)light-25)+25);
-	/*return video::SColor(alpha,light,light,MYMAX(0,
-			pow((float)light/255.0, 0.8)*255.0));*/
-#if 1
-	// Emphase blue a bit in darker places
-	float lim = 80;
-	float power = 0.8;
-	if(light > lim)
-		return video::SColor(alpha,light,light,light);
-	else
-		return video::SColor(alpha,light,light,MYMAX(0,
-				pow((float)light/lim, power)*lim));
-#endif
-}
-
 struct FastFace
 {
 	TileSpec tile;
 	video::S3DVertex vertices[4]; // Precalculated vertices
 };
 
-static 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)
+static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3,
+		v3f p, v3s16 dir, v3f scale, 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];
@@ -230,7 +430,7 @@ static void makeFastFace(TileSpec tile, u8 li0, u8 li1, u8 li2, u8 li3, v3f p,
 		vertex_pos[i].X *= scale.X;
 		vertex_pos[i].Y *= scale.Y;
 		vertex_pos[i].Z *= scale.Z;
-		vertex_pos[i] += pos + posRelative_f;
+		vertex_pos[i] += pos;
 	}
 
 	f32 abs_scale = 1.;
@@ -241,26 +441,12 @@ static void makeFastFace(TileSpec tile, u8 li0, u8 li1, u8 li2, u8 li3, v3f p,
 	v3f normal(dir.X, dir.Y, dir.Z);
 
 	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 = MapBlock_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], normal,
 			MapBlock_LightColor(alpha, li0),
 			core::vector2d<f32>(x0+w*abs_scale, y0+h));
@@ -275,14 +461,89 @@ static void makeFastFace(TileSpec tile, u8 li0, u8 li1, u8 li2, u8 li3, v3f p,
 			core::vector2d<f32>(x0+w*abs_scale, y0));
 
 	face.tile = tile;
-	//DEBUG
-	//f->tile = TILE_STONE;
 	
 	dest.push_back(face);
 }
+
+/*
+	Nodes make a face if contents differ and solidness differs.
+	Return value:
+		0: No face
+		1: Face uses m1's content
+		2: Face uses m2's content
+	equivalent: Whether the blocks share the same face (eg. water and glass)
+
+	TODO: Add 3: Both faces drawn with backface culling, remove equivalent
+*/
+static u8 face_contents(content_t m1, content_t m2, bool *equivalent,
+		INodeDefManager *ndef)
+{
+	*equivalent = false;
+
+	if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
+		return 0;
+	
+	bool contents_differ = (m1 != m2);
+	
+	const ContentFeatures &f1 = ndef->get(m1);
+	const ContentFeatures &f2 = ndef->get(m2);
+
+	// Contents don't differ for different forms of same liquid
+	if(f1.sameLiquid(f2))
+		contents_differ = false;
+	
+	u8 c1 = f1.solidness;
+	u8 c2 = f2.solidness;
+
+	bool solidness_differs = (c1 != c2);
+	bool makes_face = contents_differ && solidness_differs;
+
+	if(makes_face == false)
+		return 0;
 	
-static TileSpec getTile(const MapNode &node, v3s16 dir, INodeDefManager *nodemgr)
+	if(c1 == 0)
+		c1 = f1.visual_solidness;
+	if(c2 == 0)
+		c2 = f2.visual_solidness;
+	
+	if(c1 == c2){
+		*equivalent = true;
+		// If same solidness, liquid takes precense
+		if(f1.isLiquid())
+			return 1;
+		if(f2.isLiquid())
+			return 2;
+	}
+	
+	if(c1 > c2)
+		return 1;
+	else
+		return 2;
+}
+
+/*
+	Gets nth node tile (0 <= n <= 5).
+*/
+TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data)
 {
+	INodeDefManager *ndef = data->m_gamedef->ndef();
+	TileSpec spec = ndef->get(mn).tiles[tileindex];
+	// Apply temporary crack
+	if(p == data->m_crack_pos_relative)
+	{
+		spec.material_flags |= MATERIAL_FLAG_CRACK;
+		spec.texture = data->m_gamedef->tsrc()->getTextureRawAP(spec.texture);
+	}
+	return spec;
+}
+
+/*
+	Gets node tile given a face direction.
+*/
+TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data)
+{
+	INodeDefManager *ndef = data->m_gamedef->ndef();
+
 	// Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0),
 	// (0,0,1), (0,0,-1) or (0,0,0)
 	assert(dir.X * dir.X + dir.Y * dir.Y + dir.Z * dir.Z <= 1);
@@ -299,7 +560,7 @@ static TileSpec getTile(const MapNode &node, v3s16 dir, INodeDefManager *nodemgr
 	u8 dir_i = (dir.X + 2 * dir.Y + 3 * dir.Z) & 7;
 
 	// Get rotation for things like chests
-	u8 facedir = node.getFaceDir(nodemgr);
+	u8 facedir = mn.getFaceDir(ndef);
 	assert(facedir <= 3);
 	
 	static const u8 dir_to_tile[4 * 8] =
@@ -310,196 +571,36 @@ static TileSpec getTile(const MapNode &node, v3s16 dir, INodeDefManager *nodemgr
 		   0,  3,  0,  5,  0,  4,  1,  2,  // facedir = 2
 		   0,  5,  0,  2,  0,  3,  1,  4,  // facedir = 3
 	};
-
-	return nodemgr->get(node).tiles[dir_to_tile[facedir*8 + dir_i]];
-}
-
-/*
-	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, ITextureSource *tsrc, INodeDefManager *ndef)
-{
-	TileSpec spec;
-	spec = getTile(mn, face_dir, ndef);
-	
-	/*
-		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 && temp_mods->get(p, &mod))
-	{
-		#if 0  // NODEMOD_CHANGECONTENT isn't used at the moment
-		if(mod.type == NODEMOD_CHANGECONTENT)
-		{
-			MapNode mn2(mod.param);
-			spec = getTile(mn2, face_dir, ndef);
-		}
-		#endif
-		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 = tsrc->getTextureName(orig_id);
-
-			// Create new texture name
-			std::ostringstream os;
-			os<<orig_name<<"^[crack"<<mod.param;
-
-			// Get new texture
-			u32 new_id = tsrc->getTextureId(os.str());
-			
-			/*dstream<<"MapBlock::getNodeTile(): Switching from "
-					<<orig_name<<" to "<<os.str()<<" ("
-					<<orig_id<<" to "<<new_id<<")"<<std::endl;*/
-			
-			spec.texture = tsrc->getTexture(new_id);
-		}
-	}
-	
-	return spec;
-}
-
-static content_t getNodeContent(v3s16 p, MapNode mn, NodeModMap *temp_mods)
-{
-	/*
-		Check temporary modifications on this node
-	*/
-	#if 0  // NODEMOD_CHANGECONTENT isn't used at the moment
-	NodeMod mod;
-	if(temp_mods && 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.
-			*/
-		}
-	}
-	#endif
-
-	return mn.getContent();
-}
-
-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
-static u8 getSmoothLight(v3s16 p, VoxelManipulator &vmanip, u32 daynight_ratio,
-		INodeDefManager *ndef)
-{
-	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(ndef->get(n).param_type == CPT_LIGHT
-				// Fast-style leaves look better this way
-				&& ndef->get(n).solidness != 2)
-		{
-			light += decode_light(n.getLightBlend(daynight_ratio, ndef));
-			light_count++;
-		}
-		else
-		{
-			if(n.getContent() != 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
-static u8 getSmoothLight(v3s16 p, v3s16 corner,
-		VoxelManipulator &vmanip, u32 daynight_ratio, INodeDefManager *ndef)
-{
-	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, ndef);
+	u8 tileindex = dir_to_tile[facedir*8 + dir_i];
+	return getNodeTileN(mn, p, tileindex, data);
 }
 
 static void getTileInfo(
 		// Input:
-		v3s16 blockpos_nodes,
+		MeshMakeData *data,
 		v3s16 p,
 		v3s16 face_dir,
-		u32 daynight_ratio,
-		VoxelManipulator &vmanip,
-		NodeModMap *temp_mods,
-		bool smooth_lighting,
-		IGameDef *gamedef,
 		// Output:
 		bool &makes_face,
 		v3s16 &p_corrected,
 		v3s16 &face_dir_corrected,
-		u8 *lights,
+		u16 *lights,
 		TileSpec &tile
 	)
 {
-	ITextureSource *tsrc = gamedef->tsrc();
-	INodeDefManager *ndef = gamedef->ndef();
+	VoxelManipulator &vmanip = data->m_vmanip;
+	INodeDefManager *ndef = data->m_gamedef->ndef();
+	v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
 
 	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, tsrc, ndef);
-	TileSpec tile1 = getNodeTile(n1, p + face_dir, -face_dir, temp_mods, tsrc, ndef);
+	TileSpec tile0 = getNodeTile(n0, p, face_dir, data);
+	TileSpec tile1 = getNodeTile(n1, p + face_dir, -face_dir, data);
 	
 	// This is hackish
-	content_t content0 = getNodeContent(p, n0, temp_mods);
-	content_t content1 = getNodeContent(p + face_dir, n1, temp_mods);
 	bool equivalent = false;
-	u8 mf = face_contents(content0, content1, &equivalent, ndef);
+	u8 mf = face_contents(n0.getContent(), n1.getContent(),
+			&equivalent, ndef);
 
 	if(mf == 0)
 	{
@@ -526,10 +627,10 @@ static void getTileInfo(
 	if(equivalent)
 		tile.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
 	
-	if(smooth_lighting == false)
+	if(data->m_smooth_lighting == false)
 	{
 		lights[0] = lights[1] = lights[2] = lights[3] =
-				decode_light(getFaceLight(daynight_ratio, n0, n1, face_dir, ndef));
+				getFaceLight(n0, n1, face_dir, data);
 	}
 	else
 	{
@@ -537,8 +638,9 @@ static void getTileInfo(
 		getNodeVertexDirs(face_dir_corrected, vertex_dirs);
 		for(u16 i=0; i<4; i++)
 		{
-			lights[i] = getSmoothLight(blockpos_nodes + p_corrected,
-					vertex_dirs[i], vmanip, daynight_ratio, ndef);
+			lights[i] = getSmoothLight(
+					blockpos_nodes + p_corrected,
+					vertex_dirs[i], data);
 		}
 	}
 	
@@ -551,20 +653,13 @@ static void getTileInfo(
 	face_dir: unit vector with only one of x, y or z
 */
 static void updateFastFaceRow(
-		u32 daynight_ratio,
-		v3f posRelative_f,
+		MeshMakeData *data,
 		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,
-		IGameDef *gamedef)
+		core::array<FastFace> &dest)
 {
 	v3s16 p = startpos;
 	
@@ -573,13 +668,13 @@ static void updateFastFaceRow(
 	bool makes_face = false;
 	v3s16 p_corrected;
 	v3s16 face_dir_corrected;
-	u8 lights[4] = {0,0,0,0};
+	u16 lights[4] = {0,0,0,0};
 	TileSpec tile;
-	getTileInfo(blockpos_nodes, p, face_dir, daynight_ratio,
-			vmanip, temp_mods, smooth_lighting, gamedef,
-			makes_face, p_corrected, face_dir_corrected, lights, tile);
+	getTileInfo(data, p, face_dir, 
+			makes_face, p_corrected, face_dir_corrected,
+			lights, tile);
 
-	for(u16 j=0; j<length; j++)
+	for(u16 j=0; j<MAP_BLOCKSIZE; j++)
 	{
 		// If tiling can be done, this is set to false in the next step
 		bool next_is_different = true;
@@ -589,17 +684,16 @@ static void updateFastFaceRow(
 		bool next_makes_face = false;
 		v3s16 next_p_corrected;
 		v3s16 next_face_dir_corrected;
-		u8 next_lights[4] = {0,0,0,0};
+		u16 next_lights[4] = {0,0,0,0};
 		TileSpec next_tile;
 		
 		// If at last position, there is nothing to compare to and
 		// the face must be drawn anyway
-		if(j != length - 1)
+		if(j != MAP_BLOCKSIZE - 1)
 		{
 			p_next = p + translate_dir;
 			
-			getTileInfo(blockpos_nodes, p_next, face_dir, daynight_ratio,
-					vmanip, temp_mods, smooth_lighting, gamedef,
+			getTileInfo(data, p_next, face_dir,
 					next_makes_face, next_p_corrected,
 					next_face_dir_corrected, next_lights,
 					next_tile);
@@ -688,7 +782,7 @@ static void updateFastFaceRow(
 				
 				makeFastFace(tile, lights[0], lights[1], lights[2], lights[3],
 						sp, face_dir_corrected, scale,
-						posRelative_f, dest);
+						dest);
 				
 				g_profiler->avg("Meshgen: faces drawn by tiling", 0);
 				for(int i=1; i<continuous_tiles_count; i++){
@@ -712,26 +806,74 @@ static void updateFastFaceRow(
 	}
 }
 
-scene::SMesh* makeMapBlockMesh(MeshMakeData *data, IGameDef *gamedef)
+static void updateAllFastFaceRows(MeshMakeData *data,
+		core::array<FastFace> &dest)
 {
-	// 4-21ms for MAP_BLOCKSIZE=16
-	// 24-155ms for MAP_BLOCKSIZE=32
-	//TimeTaker timer1("makeMapBlockMesh()");
+	/*
+		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,
+					v3s16(0,y,z),
+					v3s16(1,0,0), //dir
+					v3f  (1,0,0),
+					v3s16(0,1,0), //face dir
+					v3f  (0,1,0),
+					dest);
+		}
+	}
 
-	core::array<FastFace> fastfaces_new;
+	/*
+		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,
+					v3s16(x,y,0),
+					v3s16(0,0,1), //dir
+					v3f  (0,0,1),
+					v3s16(1,0,0), //face dir
+					v3f  (1,0,0),
+					dest);
+		}
+	}
 
-	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
+		Go through every y,z and get back(z+) faces in rows of x+
 	*/
-	//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");
-	
+	for(s16 z=0; z<MAP_BLOCKSIZE; z++){
+		for(s16 y=0; y<MAP_BLOCKSIZE; y++){
+			updateFastFaceRow(data,
+					v3s16(0,y,z),
+					v3s16(1,0,0), //dir
+					v3f  (1,0,0),
+					v3s16(0,0,1), //face dir
+					v3f  (0,0,1),
+					dest);
+		}
+	}
+}
+
+/*
+	MapBlockMesh
+*/
+
+MapBlockMesh::MapBlockMesh(MeshMakeData *data):
+	m_mesh(new scene::SMesh()),
+	m_gamedef(data->m_gamedef),
+	m_animation_force_timer(0), // force initial animation
+	m_last_crack(-1),
+	m_crack_materials(),
+	m_last_daynight_ratio((u32) -1),
+	m_daynight_diffs()
+{
+	// 4-21ms for MAP_BLOCKSIZE=16  (NOTE: probably outdated)
+	// 24-155ms for MAP_BLOCKSIZE=32  (NOTE: probably outdated)
+	//TimeTaker timer1("MapBlockMesh()");
+
+	core::array<FastFace> fastfaces_new;
+
 	/*
 		We are including the faces of the trailing edges of the block.
 		This means that when something changes, the caller must
@@ -739,92 +881,23 @@ scene::SMesh* makeMapBlockMesh(MeshMakeData *data, IGameDef *gamedef)
 
 		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,
-						gamedef);
-			}
-		}
-		/*
-			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,
-						gamedef);
-			}
-		}
-		/*
-			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,
-						gamedef);
-			}
-		}
+		// 4-23ms for MAP_BLOCKSIZE=16  (NOTE: probably outdated)
+		//TimeTaker timer2("updateAllFastFaceRows()");
+		updateAllFastFaceRows(data, fastfaces_new);
 	}
-
 	// End of slow part
 
 	/*
-		Convert FastFaces to SMesh
+		Convert FastFaces to MeshCollector
 	*/
 
 	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_BACK_FACE_CULLING, true);
-		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);
-		material.MaterialType
-				= video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
+		// (NOTE: probably outdated)
+		//TimeTaker timer2("MeshCollector building");
 
 		for(u32 i=0; i<fastfaces_new.size(); i++)
 		{
@@ -833,25 +906,21 @@ scene::SMesh* makeMapBlockMesh(MeshMakeData *data, IGameDef *gamedef)
 			const u16 indices[] = {0,1,2,2,3,0};
 			const u16 indices_alternate[] = {0,1,3,2,3,1};
 			
-			video::ITexture *texture = f.tile.texture.atlas;
-			if(texture == NULL)
+			if(f.tile.texture.atlas == NULL)
 				continue;
 
-			material.setTexture(0, texture);
-			
-			f.tile.applyMaterialOptions(material);
-
 			const u16 *indices_p = indices;
 			
 			/*
 				Revert triangles for nicer looking gradient if vertices
 				1 and 3 have same color or 0 and 2 have different color.
+				getRed() is the day color.
 			*/
-			if(f.vertices[0].Color != f.vertices[2].Color
-					|| f.vertices[1].Color == f.vertices[3].Color)
+			if(f.vertices[0].Color.getRed() != f.vertices[2].Color.getRed()
+					|| f.vertices[1].Color.getRed() == f.vertices[3].Color.getRed())
 				indices_p = indices_alternate;
 			
-			collector.append(material, f.vertices, 4, indices_p, 6);
+			collector.append(f.tile, f.vertices, 4, indices_p, 6);
 		}
 	}
 
@@ -863,45 +932,91 @@ scene::SMesh* makeMapBlockMesh(MeshMakeData *data, IGameDef *gamedef)
 		- whatever
 	*/
 
-	mapblock_mesh_generate_special(data, collector, gamedef);
+	mapblock_mesh_generate_special(data, collector);
 	
-	/*
-		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
+		Convert MeshCollector to SMesh
+		Also store animation info
 	*/
+	for(u32 i = 0; i < collector.prebuffers.size(); i++)
+	{
+		PreMeshBuffer &p = collector.prebuffers[i];
+		/*dstream<<"p.vertices.size()="<<p.vertices.size()
+				<<", p.indices.size()="<<p.indices.size()
+				<<std::endl;*/
+
+		// Generate animation data
+		// - Cracks
+		if(p.tile.material_flags & MATERIAL_FLAG_CRACK)
+		{
+			ITextureSource *tsrc = data->m_gamedef->tsrc();
+			std::string crack_basename = tsrc->getTextureName(p.tile.texture.id);
+			if(p.tile.material_flags & MATERIAL_FLAG_CRACK_OVERLAY)
+				crack_basename += "^[cracko";
+			else
+				crack_basename += "^[crack";
+			m_crack_materials.insert(std::make_pair(i, crack_basename));
+		}
+		// - Lighting
+		for(u32 j = 0; j < p.vertices.size(); j++)
+		{
+			video::SColor &vc = p.vertices[j].Color;
+			u8 day = vc.getRed();
+			u8 night = vc.getGreen();
+			finalColorBlend(vc, day, night, 1000);
+			if(day != night)
+				m_daynight_diffs[i][j] = std::make_pair(day, night);
+		}
+
 
-	mesh_new->recalculateBoundingBox();
+		// Create material
+		video::SMaterial material;
+		material.setFlag(video::EMF_LIGHTING, false);
+		material.setFlag(video::EMF_BACK_FACE_CULLING, true);
+		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);
+		material.MaterialType
+				= video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
+		material.setTexture(0, p.tile.texture.atlas);
+		p.tile.applyMaterialOptions(material);
+
+		// Create meshbuffer
+
+		// This is a "Standard MeshBuffer",
+		// it's a typedeffed CMeshBuffer<video::S3DVertex>
+		scene::SMeshBuffer *buf = new scene::SMeshBuffer();
+		// Set material
+		buf->Material = material;
+		// Add to mesh
+		m_mesh->addMeshBuffer(buf);
+		// Mesh grabbed it
+		buf->drop();
+		buf->append(p.vertices.pointer(), p.vertices.size(),
+				p.indices.pointer(), p.indices.size());
+	}
 
 	/*
-		Delete new mesh if it is empty
+		Do some stuff to the mesh
 	*/
 
-	if(mesh_new->getMeshBufferCount() == 0)
-	{
-		mesh_new->drop();
-		mesh_new = NULL;
-	}
+	translateMesh(m_mesh, intToFloat(data->m_blockpos * MAP_BLOCKSIZE, BS));
+	m_mesh->recalculateBoundingBox(); // translateMesh already does this
 
-	if(mesh_new)
+	if(m_mesh)
 	{
 #if 0
 		// Usually 1-700 faces and 1-7 materials
 		std::cout<<"Updated MapBlock has "<<fastfaces_new.size()<<" faces "
-				<<"and uses "<<mesh_new->getMeshBufferCount()
+				<<"and uses "<<m_mesh->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);
+		//m_mesh->setHardwareMappingHint(scene::EHM_STATIC);
 
 		/*
 			NOTE: If that is enabled, some kind of a queue to the main
@@ -909,9 +1024,118 @@ scene::SMesh* makeMapBlockMesh(MeshMakeData *data, IGameDef *gamedef)
 			the hardware buffer and then delete the mesh
 		*/
 	}
-
-	return mesh_new;
 	
 	//std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
+
+	// Check if animation is required for this mesh
+	m_has_animation =
+		!m_crack_materials.empty() ||
+		!m_daynight_diffs.empty();
+}
+
+MapBlockMesh::~MapBlockMesh()
+{
+	m_mesh->drop();
+	m_mesh = NULL;
 }
 
+bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_ratio)
+{
+	if(!m_has_animation)
+	{
+		m_animation_force_timer = 100000;
+		return false;
+	}
+
+	m_animation_force_timer = myrand_range(5, 100);
+
+	// Cracks
+	if(crack != m_last_crack)
+	{
+		for(std::map<u32, std::string>::iterator
+				i = m_crack_materials.begin();
+				i != m_crack_materials.end(); i++)
+		{
+			scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
+			std::string basename = i->second;
+
+			// Create new texture name from original
+			ITextureSource *tsrc = m_gamedef->getTextureSource();
+			std::ostringstream os;
+			os<<basename<<crack;
+			AtlasPointer ap = tsrc->getTexture(os.str());
+			buf->getMaterial().setTexture(0, ap.atlas);
+		}
+
+		m_last_crack = crack;
+	}
+
+	// Day-night transition
+	if(daynight_ratio != m_last_daynight_ratio)
+	{
+		for(std::map<u32, std::map<u32, std::pair<u8, u8> > >::iterator
+				i = m_daynight_diffs.begin();
+				i != m_daynight_diffs.end(); i++)
+		{
+			scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
+			video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
+			for(std::map<u32, std::pair<u8, u8 > >::iterator
+					j = i->second.begin();
+					j != i->second.end(); j++)
+			{
+				u32 vertexIndex = j->first;
+				u8 day = j->second.first;
+				u8 night = j->second.second;
+				finalColorBlend(vertices[vertexIndex].Color,
+						day, night, daynight_ratio);
+			}
+		}
+		m_last_daynight_ratio = daynight_ratio;
+	}
+
+	return true;
+}
+
+/*
+	MeshCollector
+*/
+
+void MeshCollector::append(const TileSpec &tile,
+		const video::S3DVertex *vertices, u32 numVertices,
+		const u16 *indices, u32 numIndices)
+{
+	PreMeshBuffer *p = NULL;
+	for(u32 i=0; i<prebuffers.size(); i++)
+	{
+		PreMeshBuffer &pp = prebuffers[i];
+		if(pp.tile != tile)
+			continue;
+
+		p = &pp;
+		break;
+	}
+
+	if(p == NULL)
+	{
+		PreMeshBuffer pp;
+		pp.tile = tile;
+		prebuffers.push_back(pp);
+		p = &prebuffers[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]);
+	}
+}