X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fvoxel.cpp;h=87773b240f8edeb1bf9444e9b621c2794dd73131;hb=65c09a96f41705bb8e75fc5ff4276342be91ed11;hp=b85ba866642e5dd6747b771c621ed2e9460fcf4b;hpb=db49f37692d6a23db3e521736e5adcf285022827;p=minetest.git

diff --git a/src/voxel.cpp b/src/voxel.cpp
index b85ba8666..87773b240 100644
--- a/src/voxel.cpp
+++ b/src/voxel.cpp
@@ -1,28 +1,28 @@
 /*
-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 "voxel.h"
 #include "map.h"
-
-// For TimeTaker
-#include "main.h"
-#include "utility.h"
+#include "gettime.h"
+#include "nodedef.h"
+#include "util/timetaker.h"
+#include <string.h>  // memcpy, memset
 
 /*
 	Debug stuff
@@ -46,31 +46,26 @@ VoxelManipulator::VoxelManipulator():
 VoxelManipulator::~VoxelManipulator()
 {
 	clear();
-	if(m_data)
-		delete[] m_data;
-	if(m_flags)
-		delete[] m_flags;
 }
 
 void VoxelManipulator::clear()
 {
 	// Reset area to volume=0
 	m_area = VoxelArea();
-	if(m_data)
-		delete[] m_data;
+	delete[] m_data;
 	m_data = NULL;
-	if(m_flags)
-		delete[] m_flags;
+	delete[] m_flags;
 	m_flags = NULL;
 }
 
-void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
+void VoxelManipulator::print(std::ostream &o, INodeDefManager *ndef,
+		VoxelPrintMode mode)
 {
 	v3s16 em = m_area.getExtent();
 	v3s16 of = m_area.MinEdge;
 	o<<"size: "<<em.X<<"x"<<em.Y<<"x"<<em.Z
 	 <<" offset: ("<<of.X<<","<<of.Y<<","<<of.Z<<")"<<std::endl;
-	
+
 	for(s32 y=m_area.MaxEdge.Y; y>=m_area.MinEdge.Y; y--)
 	{
 		if(em.X >= 3 && em.Y >= 3)
@@ -87,15 +82,14 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 			{
 				u8 f = m_flags[m_area.index(x,y,z)];
 				char c;
-				if(f & VOXELFLAG_NOT_LOADED)
+				if(f & VOXELFLAG_NO_DATA)
 					c = 'N';
-				else if(f & VOXELFLAG_INEXISTENT)
-					c = 'I';
 				else
 				{
 					c = 'X';
-					u8 m = m_data[m_area.index(x,y,z)].d;
-					u8 pr = m_data[m_area.index(x,y,z)].pressure;
+					MapNode n = m_data[m_area.index(x,y,z)];
+					content_t m = n.getContent();
+					u8 pr = n.param2;
 					if(mode == VOXELPRINT_MATERIAL)
 					{
 						if(m <= 9)
@@ -103,13 +97,13 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 					}
 					else if(mode == VOXELPRINT_WATERPRESSURE)
 					{
-						if(m == MATERIAL_WATER)
+						if(ndef->get(m).isLiquid())
 						{
 							c = 'w';
 							if(pr <= 9)
 								c = pr + '0';
 						}
-						else if(m == MATERIAL_AIR)
+						else if(m == CONTENT_AIR)
 						{
 							c = ' ';
 						}
@@ -118,6 +112,21 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 							c = '#';
 						}
 					}
+					else if(mode == VOXELPRINT_LIGHT_DAY)
+					{
+						if(ndef->get(m).light_source != 0)
+							c = 'S';
+						else if(ndef->get(m).light_propagates == false)
+							c = 'X';
+						else
+						{
+							u8 light = n.getLight(LIGHTBANK_DAY, ndef);
+							if(light < 10)
+								c = '0' + light;
+							else
+								c = 'a' + (light-10);
+						}
+					}
 				}
 				o<<c;
 			}
@@ -127,22 +136,22 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 	}
 }
 
-void VoxelManipulator::addArea(VoxelArea area)
+void VoxelManipulator::addArea(const VoxelArea &area)
 {
 	// Cancel if requested area has zero volume
-	if(area.getExtent() == v3s16(0,0,0))
+	if (area.hasEmptyExtent())
 		return;
-	
+
 	// Cancel if m_area already contains the requested area
 	if(m_area.contains(area))
 		return;
-	
-	TimeTaker timer("addArea", g_device, &addarea_time);
+
+	TimeTaker timer("addArea", &addarea_time);
 
 	// Calculate new area
 	VoxelArea new_area;
 	// New area is the requested area if m_area has zero volume
-	if(m_area.getExtent() == v3s16(0,0,0))
+	if(m_area.hasEmptyExtent())
 	{
 		new_area = area;
 	}
@@ -164,32 +173,31 @@ void VoxelManipulator::addArea(VoxelArea area)
 	dstream<<", new_size="<<new_size;
 	dstream<<std::endl;*/
 
-	// Allocate and clear new data
+	// Allocate new data and clear flags
 	MapNode *new_data = new MapNode[new_size];
+	assert(new_data);
 	u8 *new_flags = new u8[new_size];
-	for(s32 i=0; i<new_size; i++)
-	{
-		new_flags[i] = VOXELFLAG_NOT_LOADED;
-	}
-	
+	assert(new_flags);
+	memset(new_flags, VOXELFLAG_NO_DATA, new_size);
+
 	// Copy old data
-	
+	s32 old_x_width = m_area.MaxEdge.X - m_area.MinEdge.X + 1;
 	for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
 	for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
-	for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
 	{
-		// If loaded, copy data and flags
-		if((m_flags[m_area.index(x,y,z)] & VOXELFLAG_NOT_LOADED) == false)
-		{
-			new_data[new_area.index(x,y,z)] = m_data[m_area.index(x,y,z)];
-			new_flags[new_area.index(x,y,z)] = m_flags[m_area.index(x,y,z)];
-		}
+		unsigned int old_index = m_area.index(m_area.MinEdge.X,y,z);
+		unsigned int new_index = new_area.index(m_area.MinEdge.X,y,z);
+
+		memcpy(&new_data[new_index], &m_data[old_index],
+				old_x_width * sizeof(MapNode));
+		memcpy(&new_flags[new_index], &m_flags[old_index],
+				old_x_width * sizeof(u8));
 	}
 
 	// Replace area, data and flags
-	
+
 	m_area = new_area;
-	
+
 	MapNode *old_data = m_data;
 	u8 *old_flags = m_flags;
 
@@ -198,100 +206,89 @@ void VoxelManipulator::addArea(VoxelArea area)
 
 	m_data = new_data;
 	m_flags = new_flags;
-	
-	if(old_data)
-		delete[] old_data;
-	if(old_flags)
-		delete[] old_flags;
+
+	delete[] old_data;
+	delete[] old_flags;
 
 	//dstream<<"addArea done"<<std::endl;
 }
 
-void VoxelManipulator::copyFrom(MapNode *src, VoxelArea src_area,
+void VoxelManipulator::copyFrom(MapNode *src, const VoxelArea& src_area,
 		v3s16 from_pos, v3s16 to_pos, v3s16 size)
 {
-	for(s16 z=0; z<size.Z; z++)
-	for(s16 y=0; y<size.Y; y++)
-	{
-		s32 i_src = src_area.index(from_pos.X, from_pos.Y+y, from_pos.Z+z);
-		s32 i_local = m_area.index(to_pos.X, to_pos.Y+y, to_pos.Z+z);
-		memcpy(&m_data[i_local], &src[i_src], size.X*sizeof(MapNode));
-		memset(&m_flags[i_local], 0, size.X);
+	/* The reason for this optimised code is that we're a member function
+	 * and the data type/layout of m_data is know to us: it's stored as
+	 * [z*h*w + y*h + x]. Therefore we can take the calls to m_area index
+	 * (which performs the preceding mapping/indexing of m_data) out of the
+	 * inner loop and calculate the next index as we're iterating to gain
+	 * performance.
+	 *
+	 * src_step and dest_step is the amount required to be added to our index
+	 * every time y increments. Because the destination area may be larger
+	 * than the source area we need one additional variable (otherwise we could
+	 * just continue adding dest_step as is done for the source data): dest_mod.
+	 * dest_mod is the difference in size between a "row" in the source data
+	 * and a "row" in the destination data (I am using the term row loosely
+	 * and for illustrative purposes). E.g.
+	 *
+	 * src       <-------------------->|'''''' dest mod ''''''''
+	 * dest      <--------------------------------------------->
+	 *
+	 * dest_mod (it's essentially a modulus) is added to the destination index
+	 * after every full iteration of the y span.
+	 *
+	 * This method falls under the category "linear array and incrementing
+	 * index".
+	 */
+
+	s32 src_step = src_area.getExtent().X;
+	s32 dest_step = m_area.getExtent().X;
+	s32 dest_mod = m_area.index(to_pos.X, to_pos.Y, to_pos.Z + 1)
+			- m_area.index(to_pos.X, to_pos.Y, to_pos.Z)
+			- dest_step * size.Y;
+
+	s32 i_src = src_area.index(from_pos.X, from_pos.Y, from_pos.Z);
+	s32 i_local = m_area.index(to_pos.X, to_pos.Y, to_pos.Z);
+
+	for (s16 z = 0; z < size.Z; z++) {
+		for (s16 y = 0; y < size.Y; y++) {
+			memcpy(&m_data[i_local], &src[i_src], size.X * sizeof(*m_data));
+			memset(&m_flags[i_local], 0, size.X);
+			i_src += src_step;
+			i_local += dest_step;
+		}
+		i_local += dest_mod;
 	}
 }
 
-void VoxelManipulator::interpolate(VoxelArea area)
+void VoxelManipulator::copyTo(MapNode *dst, const VoxelArea& dst_area,
+		v3s16 dst_pos, v3s16 from_pos, v3s16 size)
 {
-	VoxelArea emerge_area = area;
-	emerge_area.MinEdge -= v3s16(1,1,1);
-	emerge_area.MaxEdge += v3s16(1,1,1);
-	emerge(emerge_area);
-
-	SharedBuffer<u8> buf(area.getVolume());
-
-	for(s32 z=area.MinEdge.Z; z<=area.MaxEdge.Z; z++)
-	for(s32 y=area.MinEdge.Y; y<=area.MaxEdge.Y; y++)
-	for(s32 x=area.MinEdge.X; x<=area.MaxEdge.X; x++)
+	for(s16 z=0; z<size.Z; z++)
+	for(s16 y=0; y<size.Y; y++)
 	{
-		v3s16 p(x,y,z);
-
-		v3s16 dirs[] = {
-			v3s16(1,1,0),
-			v3s16(1,0,1),
-			v3s16(1,-1,0),
-			v3s16(1,0,-1),
-			v3s16(-1,1,0),
-			v3s16(-1,0,1),
-			v3s16(-1,-1,0),
-			v3s16(-1,0,-1),
-		};
-		//const v3s16 *dirs = g_26dirs;
-		
-		s16 total = 0;
-		s16 airness = 0;
-		u8 m = MATERIAL_IGNORE;
-
-		for(s16 i=0; i<8; i++)
-		//for(s16 i=0; i<26; i++)
-		{
-			v3s16 p2 = p + dirs[i];
-
-			u8 f = m_flags[m_area.index(p2)];
-			assert(!(f & VOXELFLAG_NOT_LOADED));
-			if(f & VOXELFLAG_INEXISTENT)
-				continue;
-
-			MapNode &n = m_data[m_area.index(p2)];
-
-			airness += (n.d == MATERIAL_AIR) ? 1 : -1;
-			total++;
-
-			if(m == MATERIAL_IGNORE && n.d != MATERIAL_AIR)
-				m = n.d;
+		s32 i_dst = dst_area.index(dst_pos.X, dst_pos.Y+y, dst_pos.Z+z);
+		s32 i_local = m_area.index(from_pos.X, from_pos.Y+y, from_pos.Z+z);
+		for (s16 x = 0; x < size.X; x++) {
+			if (m_data[i_local].getContent() != CONTENT_IGNORE)
+				dst[i_dst] = m_data[i_local];
+			i_dst++;
+			i_local++;
 		}
-
-		// 1 if air, 0 if not
-		buf[area.index(p)] = airness > -total/2 ? MATERIAL_AIR : m;
-		//buf[area.index(p)] = airness > -total ? MATERIAL_AIR : m;
-		//buf[area.index(p)] = airness >= -7 ? MATERIAL_AIR : m;
-	}
-
-	for(s32 z=area.MinEdge.Z; z<=area.MaxEdge.Z; z++)
-	for(s32 y=area.MinEdge.Y; y<=area.MaxEdge.Y; y++)
-	for(s32 x=area.MinEdge.X; x<=area.MaxEdge.X; x++)
-	{
-		v3s16 p(x,y,z);
-		m_data[m_area.index(p)].d = buf[area.index(p)];
 	}
 }
 
+/*
+	Algorithms
+	-----------------------------------------------------
+*/
 
 void VoxelManipulator::clearFlag(u8 flags)
 {
 	// 0-1ms on moderate area
-	TimeTaker timer("clearFlag", g_device, &clearflag_time);
+	TimeTaker timer("clearFlag", &clearflag_time);
 
-	v3s16 s = m_area.getExtent();
+	//v3s16 s = m_area.getExtent();
 
 	/*dstream<<"clearFlag clearing area of size "
 			<<""<<s.X<<"x"<<s.Y<<"x"<<s.Z<<""
@@ -328,527 +325,259 @@ void VoxelManipulator::clearFlag(u8 flags)
 			<<volume<<" nodes"<<std::endl;*/
 }
 
-int VoxelManipulator::getWaterPressure(v3s16 p, s16 &highest_y, int recur_count)
+void VoxelManipulator::unspreadLight(enum LightBank bank, v3s16 p, u8 oldlight,
+		std::set<v3s16> & light_sources, INodeDefManager *nodemgr)
 {
-	m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED2;
-
-	if(p.Y > highest_y)
-		highest_y = p.Y;
-	
-	recur_count++;
-	if(recur_count > 30)
-		throw ProcessingLimitException
-				("getWaterPressure recur_count limit reached");
-
 	v3s16 dirs[6] = {
+		v3s16(0,0,1), // back
 		v3s16(0,1,0), // top
-		v3s16(-1,0,0), // left
 		v3s16(1,0,0), // right
 		v3s16(0,0,-1), // front
-		v3s16(0,0,1), // back
 		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
 	};
 
-	// Load neighboring nodes
-	// TODO: A bigger area would be better
-	emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)));
+	VoxelArea voxel_area(p - v3s16(1,1,1), p + v3s16(1,1,1));
+	addArea(voxel_area);
 
-	s32 i;
-	for(i=0; i<6; i++)
+	// Loop through 6 neighbors
+	for(u16 i=0; i<6; i++)
 	{
-		v3s16 p2 = p + dirs[i];
-		u8 f = m_flags[m_area.index(p2)];
-		// Ignore inexistent or checked nodes
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED2))
-			continue;
-		MapNode &n = m_data[m_area.index(p2)];
-		// Ignore non-liquid nodes
-		if(material_liquid(n.d) == false)
+		// Get the position of the neighbor node
+		v3s16 n2pos = p + dirs[i];
+
+		u32 n2i = m_area.index(n2pos);
+
+		if(m_flags[n2i] & VOXELFLAG_NO_DATA)
 			continue;
 
-		int pr;
-		
-		// If at surface
-		/*if(n.pressure == 1)
-		{
-			pr = 1;
-		}
-		// Otherwise recurse more
-		else*/
-		{
-			pr = getWaterPressure(p2, highest_y, recur_count);
-			if(pr == -1)
-				continue;
-		}
+		MapNode &n2 = m_data[n2i];
 
-		// If block is at top, pressure here is one higher
-		if(i == 0)
+		/*
+			If the neighbor is dimmer than what was specified
+			as oldlight (the light of the previous node)
+		*/
+		u8 light2 = n2.getLight(bank, nodemgr);
+		if(light2 < oldlight)
 		{
-			if(pr < 255)
-				pr++;
+			/*
+				And the neighbor is transparent and it has some light
+			*/
+			if(nodemgr->get(n2).light_propagates && light2 != 0)
+			{
+				/*
+					Set light to 0 and add to queue
+				*/
+
+				n2.setLight(bank, 0, nodemgr);
+
+				unspreadLight(bank, n2pos, light2, light_sources, nodemgr);
+
+				/*
+					Remove from light_sources if it is there
+					NOTE: This doesn't happen nearly at all
+				*/
+				/*if(light_sources.find(n2pos))
+				{
+					std::cout<<"Removed from light_sources"<<std::endl;
+					light_sources.remove(n2pos);
+				}*/
+			}
 		}
-		// If block is at bottom, pressure here is one lower
-		else if(i == 5)
-		{
-			if(pr > 1)
-				pr--;
+		else{
+			light_sources.insert(n2pos);
 		}
-		
-		// Node is on the pressure route
-		m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED4;
-
-		// Got pressure
-		return pr;
 	}
-	
-	// Nothing useful found
-	return -1;
 }
 
-void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr,
-		VoxelArea request_area,
-		core::map<v3s16, u8> &active_nodes,
-		int recur_count)
+/*
+	Goes recursively through the neighbours of the node.
+
+	Alters only transparent nodes.
+
+	If the lighting of the neighbour is lower than the lighting of
+	the node was (before changing it to 0 at the step before), the
+	lighting of the neighbour is set to 0 and then the same stuff
+	repeats for the neighbour.
+
+	The ending nodes of the routine are stored in light_sources.
+	This is useful when a light is removed. In such case, this
+	routine can be called for the light node and then again for
+	light_sources to re-light the area without the removed light.
+
+	values of from_nodes are lighting values.
+*/
+void VoxelManipulator::unspreadLight(enum LightBank bank,
+		std::map<v3s16, u8> & from_nodes,
+		std::set<v3s16> & light_sources, INodeDefManager *nodemgr)
 {
-	recur_count++;
-	if(recur_count > 10000)
-		throw ProcessingLimitException
-				("spreadWaterPressure recur_count limit reached");
+	if(from_nodes.empty())
+		return;
 
-	m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED3;
-	m_data[m_area.index(p)].pressure = pr;
+	for(std::map<v3s16, u8>::iterator j = from_nodes.begin();
+		j != from_nodes.end(); ++j)
+	{
+		unspreadLight(bank, j->first, j->second, light_sources, nodemgr);
+	}
+}
 
-	v3s16 dirs[6] = {
+void VoxelManipulator::spreadLight(enum LightBank bank, v3s16 p,
+		INodeDefManager *nodemgr)
+{
+	const v3s16 dirs[6] = {
+		v3s16(0,0,1), // back
 		v3s16(0,1,0), // top
-		v3s16(-1,0,0), // left
 		v3s16(1,0,0), // right
 		v3s16(0,0,-1), // front
-		v3s16(0,0,1), // back
 		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
 	};
 
-	// Load neighboring nodes
-	emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)));
-
-	s32 i;
-	for(i=0; i<6; i++)
-	{
-		v3s16 p2 = p + dirs[i];
-		
-		u8 f = m_flags[m_area.index(p2)];
-
-		// Ignore inexistent and checked nodes
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED3))
-			continue;
-
-		MapNode &n = m_data[m_area.index(p2)];
-		
-		/*
-			If material is air:
-				add to active_nodes if there is flow-causing pressure.
-			NOTE: Do not remove anything from there. We cannot know
-			      here if some other neighbor of it causes flow.
-		*/
-		if(n.d == MATERIAL_AIR)
-		{
-			bool pressure_causes_flow = false;
-			// If block is at top
-			if(i == 0)
-			{
-				if(pr >= 3)
-					pressure_causes_flow = true;
-			}
-			// If block is at bottom
-			else if(i == 5)
-			{
-				pressure_causes_flow = true;
-			}
-			// If block is at side
-			else
-			{
-				if(pr >= 2)
-					pressure_causes_flow = true;
-			}
-			
-			if(pressure_causes_flow)
-			{
-				active_nodes[p2] = 1;
-			}
+	VoxelArea voxel_area(p - v3s16(1,1,1), p + v3s16(1,1,1));
+	addArea(voxel_area);
 
-			continue;
-		}
+	u32 i = m_area.index(p);
 
-		// Ignore non-liquid nodes
-		if(material_liquid(n.d) == false)
-			continue;
+	if(m_flags[i] & VOXELFLAG_NO_DATA)
+		return;
 
-		int pr2 = pr;
-		// If block is at top, pressure there is lower
-		if(i == 0)
-		{
-			if(pr2 > 0)
-				pr2--;
-		}
-		// If block is at bottom, pressure there is higher
-		else if(i == 5)
-		{
-			if(pr2 < 255)
-				pr2++;
-		}
-		
-		// Ignore if correct pressure is already set and is not on
-		// request_area
-		if(n.pressure == pr2 && request_area.contains(p2) == false)
-			continue;
+	MapNode &n = m_data[i];
 
-		spreadWaterPressure(p2, pr2, request_area, active_nodes, recur_count);
-	}
-}
+	u8 oldlight = n.getLight(bank, nodemgr);
+	u8 newlight = diminish_light(oldlight);
 
-void VoxelManipulator::updateAreaWaterPressure(VoxelArea a,
-		core::map<v3s16, u8> &active_nodes,
-		bool checked3_is_clear)
-{
-	TimeTaker timer("updateAreaWaterPressure", g_device,
-			&updateareawaterpressure_time);
-
-	emerge(a);
-	
-	bool checked2_clear = false;
-	
-	if(checked3_is_clear == false)
+	// Loop through 6 neighbors
+	for(u16 i=0; i<6; i++)
 	{
-		//clearFlag(VOXELFLAG_CHECKED3);
-
-		clearFlag(VOXELFLAG_CHECKED3 | VOXELFLAG_CHECKED2);
-		checked2_clear = true;
-	}
-	
+		// Get the position of the neighbor node
+		v3s16 n2pos = p + dirs[i];
 
-	for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
-	for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
-	for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++)
-	{
-		v3s16 p(x,y,z);
+		u32 n2i = m_area.index(n2pos);
 
-		u8 f = m_flags[m_area.index(p)];
-		// Ignore inexistent or checked nodes
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED3))
-			continue;
-		MapNode &n = m_data[m_area.index(p)];
-		// Ignore non-liquid nodes
-		if(material_liquid(n.d) == false)
+		if(m_flags[n2i] & VOXELFLAG_NO_DATA)
 			continue;
-		
-		if(checked2_clear == false)
-		{
-			clearFlag(VOXELFLAG_CHECKED2);
-			checked2_clear = true;
-		}
-
-		checked2_clear = false;
 
-		s16 highest_y = -32768;
-		int recur_count = 0;
-		int pr = -1;
+		MapNode &n2 = m_data[n2i];
 
-		try
-		{
-			// 0-1ms @ recur_count <= 100
-			//TimeTaker timer("getWaterPressure", g_device);
-			pr = getWaterPressure(p, highest_y, recur_count);
-		}
-		catch(ProcessingLimitException &e)
-		{
-			//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
-		}
+		u8 light2 = n2.getLight(bank, nodemgr);
 
-		if(pr == -1)
-		{
-			assert(highest_y != -32768);
-
-			pr = highest_y - p.Y + 1;
-			if(pr > 255)
-				pr = 255;
-
-			/*dstream<<"WARNING: Pressure at ("
-					<<p.X<<","<<p.Y<<","<<p.Z<<")"
-					<<" = "<<pr
-					//<<" and highest_y == -32768"
-					<<std::endl;
-			assert(highest_y != -32768);
-			continue;*/
-		}
-		
-		try
+		/*
+			If the neighbor is brighter than the current node,
+			add to list (it will light up this node on its turn)
+		*/
+		if(light2 > undiminish_light(oldlight))
 		{
-			// 0ms
-			//TimeTaker timer("spreadWaterPressure", g_device);
-			spreadWaterPressure(p, pr, a, active_nodes, 0);
+			spreadLight(bank, n2pos, nodemgr);
 		}
-		catch(ProcessingLimitException &e)
+		/*
+			If the neighbor is dimmer than how much light this node
+			would spread on it, add to list
+		*/
+		if(light2 < newlight)
 		{
-			//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
+			if(nodemgr->get(n2).light_propagates)
+			{
+				n2.setLight(bank, newlight, nodemgr);
+				spreadLight(bank, n2pos, nodemgr);
+			}
 		}
 	}
 }
 
-bool VoxelManipulator::flowWater(v3s16 removed_pos,
-		core::map<v3s16, u8> &active_nodes,
-		int recursion_depth, bool debugprint,
-		int *counter, int counterlimit)
+
+const MapNode VoxelManipulator::ContentIgnoreNode = MapNode(CONTENT_IGNORE);
+
+/*
+	Lights neighbors of from_nodes, collects all them and then
+	goes on recursively.
+*/
+void VoxelManipulator::spreadLight(enum LightBank bank,
+		std::set<v3s16> & from_nodes, INodeDefManager *nodemgr)
 {
-	v3s16 dirs[6] = {
+	const v3s16 dirs[6] = {
+		v3s16(0,0,1), // back
 		v3s16(0,1,0), // top
-		v3s16(-1,0,0), // left
 		v3s16(1,0,0), // right
 		v3s16(0,0,-1), // front
-		v3s16(0,0,1), // back
 		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
 	};
 
-	recursion_depth++;
-
-	v3s16 p;
-	
-	// Randomize horizontal order
-	static s32 cs = 0;
-	if(cs < 3)
-		cs++;
-	else
-		cs = 0;
-	s16 s1 = (cs & 1) ? 1 : -1;
-	s16 s2 = (cs & 2) ? 1 : -1;
-	//dstream<<"s1="<<s1<<", s2="<<s2<<std::endl;
-
-	{
-	TimeTaker timer1("flowWater pre", g_device, &flowwater_pre_time);
-	
-	// Load neighboring nodes
-	emerge(VoxelArea(removed_pos - v3s16(1,1,1), removed_pos + v3s16(1,1,1)));
-	
-	// Ignore incorrect removed_pos
-	{
-		u8 f = m_flags[m_area.index(removed_pos)];
-		// Ignore inexistent or checked node
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
-			return false;
-		MapNode &n = m_data[m_area.index(removed_pos)];
-		// Water can move only to air
-		if(n.d != MATERIAL_AIR)
-			return false;
-	}
-	
-	s32 i;
-	for(i=0; i<6; i++)
-	{
-		p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z);
+	if(from_nodes.empty())
+		return;
 
-		u8 f = m_flags[m_area.index(p)];
-		// Inexistent or checked nodes can't move
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
-			continue;
-		MapNode &n = m_data[m_area.index(p)];
-		// Only liquid nodes can move
-		if(material_liquid(n.d) == false)
-			continue;
-		// If block is at top, select it always
-		if(i == 0)
-		{
-			break;
-		}
-		// If block is at bottom, select it if it has enough pressure
-		if(i == 5)
-		{
-			if(n.pressure >= 3)
-				break;
-			continue;
-		}
-		// Else block is at some side. Select it if it has enough pressure
-		if(n.pressure >= 2)
-		{
-			break;
-		}
-	}
+	std::set<v3s16> lighted_nodes;
 
-	// If there is nothing to move, return
-	if(i==6)
-		return false;
-
-	// Switch nodes at p and removed_pos
-	u8 m = m_data[m_area.index(p)].d;
-	u8 f = m_flags[m_area.index(p)];
-	m_data[m_area.index(p)].d = m_data[m_area.index(removed_pos)].d;
-	m_flags[m_area.index(p)] = m_flags[m_area.index(removed_pos)];
-	m_data[m_area.index(removed_pos)].d = m;
-	m_flags[m_area.index(removed_pos)] = f;
-
-	// Mark removed_pos checked
-	m_flags[m_area.index(removed_pos)] |= VOXELFLAG_CHECKED;
-	// If block was dropped from surface, increase pressure
-	if(i == 0 && m_data[m_area.index(removed_pos)].pressure == 1)
-	{
-		m_data[m_area.index(removed_pos)].pressure = 2;
-	}
-	
-	/*if(debugprint)
+	for(std::set<v3s16>::iterator j = from_nodes.begin();
+		j != from_nodes.end(); ++j)
 	{
-		dstream<<"VoxelManipulator::flowWater(): Moved bubble:"<<std::endl;
-		print(dstream, VOXELPRINT_WATERPRESSURE);
-	}*/
+		v3s16 pos = *j;
 
-	// Update pressure
-	VoxelArea a;
-	a.addPoint(p - v3s16(1,1,1));
-	a.addPoint(p + v3s16(1,1,1));
-	a.addPoint(removed_pos - v3s16(1,1,1));
-	a.addPoint(removed_pos + v3s16(1,1,1));
-	updateAreaWaterPressure(a, active_nodes);
-	
-	/*if(debugprint)
-	{
-		dstream<<"VoxelManipulator::flowWater(): Pressure updated:"<<std::endl;
-		print(dstream, VOXELPRINT_WATERPRESSURE);
-		//std::cin.get();
-	}*/
+		VoxelArea voxel_area(pos - v3s16(1,1,1), pos + v3s16(1,1,1));
+		addArea(voxel_area);
 
-	if(debugprint)
-	{
-		dstream<<"VoxelManipulator::flowWater(): step done:"<<std::endl;
-		print(dstream, VOXELPRINT_WATERPRESSURE);
-		//std::cin.get();
-	}
-	
-	}//timer1
-
-	// Flow water to the newly created empty position
-	flowWater(p, active_nodes, recursion_depth,
-			debugprint, counter, counterlimit);
-	
-find_again:
-	// Try flowing water to empty positions around removed_pos.
-	// They are checked in reverse order compared to the previous loop.
-	for(s32 i=5; i>=0; i--)
-	{
-		//v3s16 p = removed_pos + dirs[i];
-		p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z);
+		u32 i = m_area.index(pos);
 
-		u8 f = m_flags[m_area.index(p)];
-		// Water can't move to inexistent nodes
-		if(f & VOXELFLAG_INEXISTENT)
-			continue;
-		MapNode &n = m_data[m_area.index(p)];
-		// Water can only move to air
-		if(n.d != MATERIAL_AIR)
+		if(m_flags[i] & VOXELFLAG_NO_DATA)
 			continue;
-			
-		// Flow water to node
-		bool moved =
-		flowWater(p, active_nodes, recursion_depth,
-				debugprint, counter, counterlimit);
-		
-		if(moved)
-		{
-			// Search again from all neighbors
-			goto find_again;
-		}
-	}
 
-	if(counter != NULL)
-	{
-		(*counter)++;
-		if((*counter) % 10 == 0)
-			dstream<<"flowWater(): moved "<<(*counter)<<" nodes"
-					<<std::endl;
+		MapNode &n = m_data[i];
 
-		if(counterlimit != -1 && (*counter) > counterlimit)
-		{
-			dstream<<"Counter limit reached; returning"<<std::endl;
-			throw ProcessingLimitException("flowWater counterlimit reached");
-		}
-	}
-	
-	return true;
-}
+		u8 oldlight = n.getLight(bank, nodemgr);
+		u8 newlight = diminish_light(oldlight);
 
-void VoxelManipulator::flowWater(
-		core::map<v3s16, u8> &active_nodes,
-		int recursion_depth, bool debugprint,
-		int counterlimit)
-{
-	addarea_time = 0;
-	emerge_time = 0;
-	emerge_load_time = 0;
-	clearflag_time = 0;
-	updateareawaterpressure_time = 0;
-	flowwater_pre_time = 0;
+		// Loop through 6 neighbors
+		for(u16 i=0; i<6; i++)
+		{
+			// Get the position of the neighbor node
+			v3s16 n2pos = pos + dirs[i];
 
-	TimeTaker timer1("flowWater (active_nodes)", g_device);
+			try
+			{
+				u32 n2i = m_area.index(n2pos);
 
-	dstream<<"active_nodes.size() = "<<active_nodes.size()<<std::endl;
+				if(m_flags[n2i] & VOXELFLAG_NO_DATA)
+					continue;
 
-	int counter = 0;
+				MapNode &n2 = m_data[n2i];
 
-	try
-	{
+				u8 light2 = n2.getLight(bank, nodemgr);
 
-	// Flow water to active nodes
-	for(;;)
-	{
-		// Clear check flags
-		clearFlag(VOXELFLAG_CHECKED);
-		
-		if(active_nodes.size() == 0)
-			break;
-
-		dstream<<"Selecting a new active_node"<<std::endl;
-
-#if 0
-		// Take first one
-		core::map<v3s16, u8>::Node
-				*n = active_nodes.getIterator().getNode();
-#endif
-
-#if 1
-		// Take random one
-		s32 k = (s32)rand() % (s32)active_nodes.size();
-		//s32 k = 0;
-		core::map<v3s16, u8>::Iterator
-				i = active_nodes.getIterator().getNode();
-		for(s32 j=0; j<k; j++)
-		{
-			i++;
+				/*
+					If the neighbor is brighter than the current node,
+					add to list (it will light up this node on its turn)
+				*/
+				if(light2 > undiminish_light(oldlight))
+				{
+					lighted_nodes.insert(n2pos);
+				}
+				/*
+					If the neighbor is dimmer than how much light this node
+					would spread on it, add to list
+				*/
+				if(light2 < newlight)
+				{
+					if(nodemgr->get(n2).light_propagates)
+					{
+						n2.setLight(bank, newlight, nodemgr);
+						lighted_nodes.insert(n2pos);
+					}
+				}
+			}
+			catch(InvalidPositionException &e)
+			{
+				continue;
+			}
 		}
-		core::map<v3s16, u8>::Node *n = i.getNode();
-#endif
-
-		v3s16 p = n->getKey();
-		active_nodes.remove(p);
-		flowWater(p, active_nodes, recursion_depth,
-				debugprint, &counter, counterlimit);
 	}
 
-	}
-	catch(ProcessingLimitException &e)
-	{
-		//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
-	}
-	
-	v3s16 e = m_area.getExtent();
-	s32 v = m_area.getVolume();
-	dstream<<"flowWater (active): moved "<<counter<<" nodes, "
-			<<"area ended up as "
-			<<e.X<<"x"<<e.Y<<"x"<<e.Z<<" = "<<v
-			<<std::endl;
-	
-	dstream<<"addarea_time: "<<addarea_time
-			<<", emerge_time: "<<emerge_time
-			<<", emerge_load_time: "<<emerge_load_time
-			<<", clearflag_time: "<<clearflag_time
-			<<", flowwater_pre_time: "<<flowwater_pre_time
-			<<", updateareawaterpressure_time: "<<updateareawaterpressure_time
-			<<std::endl;
-}
+	/*dstream<<"spreadLight(): Changed block "
+			<<blockchangecount<<" times"
+			<<" for "<<from_nodes.size()<<" nodes"
+			<<std::endl;*/
 
+	if(!lighted_nodes.empty())
+		spreadLight(bank, lighted_nodes, nodemgr);
+}
 
 //END