X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fvoxel.h;h=16540e5951b817849901770c1cec6476046f7992;hb=a69b7abe00fb818fd88f3cd04e7f9997ffd21072;hp=80d292891d61eac2e515f899eda2294644576352;hpb=3909e712a012c11793effc408fd348e438a9ac5b;p=dragonfireclient.git

diff --git a/src/voxel.h b/src/voxel.h
index 80d292891..16540e595 100644
--- a/src/voxel.h
+++ b/src/voxel.h
@@ -1,36 +1,46 @@
 /*
-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.
 */
 
-#ifndef VOXEL_HEADER
-#define VOXEL_HEADER
+#pragma once
 
-#include "common_irrlicht.h"
+#include "irrlichttypes.h"
+#include "irr_v3d.h"
 #include <iostream>
-#include "debug.h"
+#include <cassert>
+#include "exceptions.h"
 #include "mapnode.h"
+#include <set>
+#include <list>
+#include "util/basic_macros.h"
+
+class NodeDefManager;
 
 // For VC++
 #undef min
 #undef max
 
 /*
-	A fast voxel manipulator class
+	A fast voxel manipulator class.
+
+	In normal operation, it fetches more map when it is requested.
+	It can also be used so that all allowed area is fetched at the
+	start, using ManualMapVoxelManipulator.
 
 	Not thread-safe.
 */
@@ -38,8 +48,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 /*
 	Debug stuff
 */
-extern u32 emerge_time;
-extern u32 emerge_load_time;
+extern u64 emerge_time;
+extern u64 emerge_load_time;
 
 /*
 	This class resembles aabbox3d<s16> a lot, but has inclusive
@@ -49,29 +59,29 @@ class VoxelArea
 {
 public:
 	// Starts as zero sized
-	VoxelArea():
-		MinEdge(1,1,1),
-		MaxEdge(0,0,0)
-	{
-	}
-	VoxelArea(v3s16 min_edge, v3s16 max_edge):
+	VoxelArea() = default;
+
+	VoxelArea(const v3s16 &min_edge, const v3s16 &max_edge):
 		MinEdge(min_edge),
 		MaxEdge(max_edge)
 	{
+		cacheExtent();
 	}
-	VoxelArea(v3s16 p):
+
+	VoxelArea(const v3s16 &p):
 		MinEdge(p),
 		MaxEdge(p)
 	{
+		cacheExtent();
 	}
-	
+
 	/*
 		Modifying methods
 	*/
 
-	void addArea(VoxelArea &a)
+	void addArea(const VoxelArea &a)
 	{
-		if(getExtent() == v3s16(0,0,0))
+		if (hasEmptyExtent())
 		{
 			*this = a;
 			return;
@@ -82,13 +92,16 @@ class VoxelArea
 		if(a.MaxEdge.X > MaxEdge.X) MaxEdge.X = a.MaxEdge.X;
 		if(a.MaxEdge.Y > MaxEdge.Y) MaxEdge.Y = a.MaxEdge.Y;
 		if(a.MaxEdge.Z > MaxEdge.Z) MaxEdge.Z = a.MaxEdge.Z;
+		cacheExtent();
 	}
-	void addPoint(v3s16 p)
+
+	void addPoint(const v3s16 &p)
 	{
-		if(getExtent() == v3s16(0,0,0))
+		if(hasEmptyExtent())
 		{
 			MinEdge = p;
 			MaxEdge = p;
+			cacheExtent();
 			return;
 		}
 		if(p.X < MinEdge.X) MinEdge.X = p.X;
@@ -97,45 +110,43 @@ class VoxelArea
 		if(p.X > MaxEdge.X) MaxEdge.X = p.X;
 		if(p.Y > MaxEdge.Y) MaxEdge.Y = p.Y;
 		if(p.Z > MaxEdge.Z) MaxEdge.Z = p.Z;
+		cacheExtent();
 	}
-	
+
 	// Pad with d nodes
-	void pad(v3s16 d)
+	void pad(const v3s16 &d)
 	{
 		MinEdge -= d;
 		MaxEdge += d;
 	}
-	
-	/*void operator+=(v3s16 off)
-	{
-		MinEdge += off;
-		MaxEdge += off;
-	}
-
-	void operator-=(v3s16 off)
-	{
-		MinEdge -= off;
-		MaxEdge -= off;
-	}*/
 
 	/*
 		const methods
 	*/
 
-	v3s16 getExtent() const
+	const v3s16 &getExtent() const
+	{
+		return m_cache_extent;
+	}
+
+	/* Because MaxEdge and MinEdge are included in the voxel area an empty extent
+	 * is not represented by (0, 0, 0), but instead (-1, -1, -1)
+	 */
+	bool hasEmptyExtent() const
 	{
-		return MaxEdge - MinEdge + v3s16(1,1,1);
+		return MaxEdge - MinEdge == v3s16(-1, -1, -1);
 	}
+
 	s32 getVolume() const
 	{
-		v3s16 e = getExtent();
-		return (s32)e.X * (s32)e.Y * (s32)e.Z;
+		return (s32)m_cache_extent.X * (s32)m_cache_extent.Y * (s32)m_cache_extent.Z;
 	}
+
 	bool contains(const VoxelArea &a) const
 	{
 		// No area contains an empty area
 		// NOTE: Algorithms depend on this, so do not change.
-		if(a.getExtent() == v3s16(0,0,0))
+		if(a.hasEmptyExtent())
 			return false;
 
 		return(
@@ -152,20 +163,24 @@ class VoxelArea
 			p.Z >= MinEdge.Z && p.Z <= MaxEdge.Z
 		);
 	}
+	bool contains(s32 i) const
+	{
+		return (i >= 0 && i < getVolume());
+	}
 	bool operator==(const VoxelArea &other) const
 	{
 		return (MinEdge == other.MinEdge
 				&& MaxEdge == other.MaxEdge);
 	}
 
-	VoxelArea operator+(v3s16 off) const
+	VoxelArea operator+(const v3s16 &off) const
 	{
-		return VoxelArea(MinEdge+off, MaxEdge+off);
+		return {MinEdge+off, MaxEdge+off};
 	}
 
-	VoxelArea operator-(v3s16 off) const
+	VoxelArea operator-(const v3s16 &off) const
 	{
-		return VoxelArea(MinEdge-off, MaxEdge-off);
+		return {MinEdge-off, MaxEdge-off};
 	}
 
 	/*
@@ -174,7 +189,7 @@ class VoxelArea
 
 		a: area inside *this
 	*/
-	void diff(const VoxelArea &a, core::list<VoxelArea> &result)
+	void diff(const VoxelArea &a, std::list<VoxelArea> &result)
 	{
 		/*
 			This can result in a maximum of 6 areas
@@ -189,8 +204,8 @@ class VoxelArea
 			return;
 		}
 
-		assert(contains(a));
-		
+		assert(contains(a));	// pre-condition
+
 		// Take back area, XY inclusive
 		{
 			v3s16 min(MinEdge.X, MinEdge.Y, a.MaxEdge.Z+1);
@@ -246,16 +261,15 @@ class VoxelArea
 		}
 
 	}
-	
+
 	/*
 		Translates position from virtual coordinates to array index
 	*/
 	s32 index(s16 x, s16 y, s16 z) const
 	{
-		v3s16 em = getExtent();
-		v3s16 off = MinEdge;
-		s32 i = (s32)(z-off.Z)*em.Y*em.X + (y-off.Y)*em.X + (x-off.X);
-		//dstream<<" i("<<x<<","<<y<<","<<z<<")="<<i<<" ";
+		s32 i = (s32)(z - MinEdge.Z) * m_cache_extent.Y * m_cache_extent.X
+			+ (y - MinEdge.Y) * m_cache_extent.X
+			+ (x - MinEdge.X);
 		return i;
 	}
 	s32 index(v3s16 p) const
@@ -263,236 +277,210 @@ class VoxelArea
 		return index(p.X, p.Y, p.Z);
 	}
 
+	/**
+	 * Translate index in the X coordinate
+	 */
+	static void add_x(const v3s16 &extent, u32 &i, s16 a)
+	{
+		i += a;
+	}
+
+	/**
+	 * Translate index in the Y coordinate
+	 */
+	static void add_y(const v3s16 &extent, u32 &i, s16 a)
+	{
+		i += a * extent.X;
+	}
+
+	/**
+	 * Translate index in the Z coordinate
+	 */
+	static void add_z(const v3s16 &extent, u32 &i, s16 a)
+	{
+		i += a * extent.X * extent.Y;
+	}
+
+	/**
+	 * Translate index in space
+	 */
+	static void add_p(const v3s16 &extent, u32 &i, v3s16 a)
+	{
+		i += a.Z * extent.X * extent.Y + a.Y * extent.X + a.X;
+	}
+
+	/*
+		Print method for debugging
+	*/
 	void print(std::ostream &o) const
 	{
-		v3s16 e = getExtent();
-		o<<"("<<MinEdge.X
-		 <<","<<MinEdge.Y
-		 <<","<<MinEdge.Z
-		 <<")("<<MaxEdge.X
-		 <<","<<MaxEdge.Y
-		 <<","<<MaxEdge.Z
-		 <<")"
-		 <<"="<<e.X<<"x"<<e.Y<<"x"<<e.Z<<"="<<getVolume();
+		o << PP(MinEdge) << PP(MaxEdge) << "="
+			<< m_cache_extent.X << "x" << m_cache_extent.Y << "x" << m_cache_extent.Z
+			<< "=" << getVolume();
 	}
 
 	// Edges are inclusive
-	v3s16 MinEdge;
+	v3s16 MinEdge = v3s16(1,1,1);
 	v3s16 MaxEdge;
+private:
+	void cacheExtent()
+	{
+		m_cache_extent = MaxEdge - MinEdge + v3s16(1,1,1);
+	}
+
+	v3s16 m_cache_extent = v3s16(0,0,0);
 };
 
-// Hasn't been copied from source (emerged)
-#define VOXELFLAG_NOT_LOADED (1<<0)
-// Checked as being inexistent in source
-#define VOXELFLAG_INEXISTENT (1<<1)
+// unused
+#define VOXELFLAG_UNUSED   (1 << 0)
+// no data about that node
+#define VOXELFLAG_NO_DATA  (1 << 1)
 // Algorithm-dependent
-// flowWater: "visited"
-#define VOXELFLAG_CHECKED (1<<2)
+#define VOXELFLAG_CHECKED1 (1 << 2)
 // Algorithm-dependent
-// getWaterPressure: "visited"
-#define VOXELFLAG_CHECKED2 (1<<3)
+#define VOXELFLAG_CHECKED2 (1 << 3)
 // Algorithm-dependent
-// spreadWaterPressure: "visited"
-#define VOXELFLAG_CHECKED3 (1<<4)
+#define VOXELFLAG_CHECKED3 (1 << 4)
 // Algorithm-dependent
-// water: "pressure check route node"
-#define VOXELFLAG_CHECKED4 (1<<5)
+#define VOXELFLAG_CHECKED4 (1 << 5)
 
 enum VoxelPrintMode
 {
 	VOXELPRINT_NOTHING,
 	VOXELPRINT_MATERIAL,
 	VOXELPRINT_WATERPRESSURE,
+	VOXELPRINT_LIGHT_DAY,
 };
 
-class VoxelManipulator /*: public NodeContainer*/
+class VoxelManipulator
 {
 public:
-	VoxelManipulator();
+	VoxelManipulator() = default;
 	virtual ~VoxelManipulator();
-	
-	/*
-		Virtuals from NodeContainer
-	*/
-	/*virtual u16 nodeContainerId() const
-	{
-		return NODECONTAINER_ID_VOXELMANIPULATOR;
-	}
-	bool isValidPosition(v3s16 p)
-	{
-		emerge(p);
-		return !(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT);
-	}*/
 
 	/*
 		These are a bit slow and shouldn't be used internally.
 		Use m_data[m_area.index(p)] instead.
 	*/
-	MapNode getNode(v3s16 p)
+	MapNode getNode(const v3s16 &p)
 	{
-		emerge(p);
+		VoxelArea voxel_area(p);
+		addArea(voxel_area);
 
-		if(m_flags[m_area.index(p)] & VOXELFLAG_INEXISTENT)
-		{
-			dstream<<"EXCEPT: VoxelManipulator::getNode(): "
+		if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA) {
+			/*dstream<<"EXCEPT: VoxelManipulator::getNode(): "
 					<<"p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 					<<", index="<<m_area.index(p)
 					<<", flags="<<(int)m_flags[m_area.index(p)]
-					<<" is inexistent"<<std::endl;
+					<<" is inexistent"<<std::endl;*/
 			throw InvalidPositionException
 			("VoxelManipulator: getNode: inexistent");
 		}
 
 		return m_data[m_area.index(p)];
 	}
-	void setNode(v3s16 p, MapNode &n)
+	MapNode getNodeNoEx(const v3s16 &p)
 	{
-		emerge(p);
-		
-		m_data[m_area.index(p)] = n;
-		m_flags[m_area.index(p)] &= ~VOXELFLAG_INEXISTENT;
-		m_flags[m_area.index(p)] &= ~VOXELFLAG_NOT_LOADED;
+		VoxelArea voxel_area(p);
+		addArea(voxel_area);
+
+		if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA) {
+			return {CONTENT_IGNORE};
+		}
+
+		return m_data[m_area.index(p)];
 	}
-	void setNodeNoRef(v3s16 p, MapNode n)
+	MapNode getNodeNoExNoEmerge(const v3s16 &p)
 	{
-		setNode(p, n);
+		if (!m_area.contains(p))
+			return {CONTENT_IGNORE};
+		if (m_flags[m_area.index(p)] & VOXELFLAG_NO_DATA)
+			return {CONTENT_IGNORE};
+		return m_data[m_area.index(p)];
+	}
+	// Stuff explodes if non-emerged area is touched with this.
+	// Emerge first, and check VOXELFLAG_NO_DATA if appropriate.
+	MapNode & getNodeRefUnsafe(const v3s16 &p)
+	{
+		return m_data[m_area.index(p)];
 	}
 
-	/*void setExists(VoxelArea a)
+	const MapNode & getNodeRefUnsafeCheckFlags(const v3s16 &p)
 	{
-		emerge(a);
-		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++)
-		{
-			m_flags[m_area.index(x,y,z)] &= ~VOXELFLAG_INEXISTENT;
-		}
-	}*/
+		s32 index = m_area.index(p);
+
+		if (m_flags[index] & VOXELFLAG_NO_DATA)
+			return ContentIgnoreNode;
+
+		return m_data[index];
+	}
 
-	/*MapNode & operator[](v3s16 p)
+	u8 & getFlagsRefUnsafe(const v3s16 &p)
 	{
-		//dstream<<"operator[] p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
-		if(isValidPosition(p) == false)
-			emerge(VoxelArea(p));
-		
-		return m_data[m_area.index(p)];
-	}*/
+		return m_flags[m_area.index(p)];
+	}
 
-	/*
-		Control
-	*/
+	bool exists(const v3s16 &p)
+	{
+		return m_area.contains(p) &&
+			!(getFlagsRefUnsafe(p) & VOXELFLAG_NO_DATA);
+	}
 
-	virtual void clear();
+	void setNode(const v3s16 &p, const MapNode &n)
+	{
+		VoxelArea voxel_area(p);
+		addArea(voxel_area);
 
-	void print(std::ostream &o, VoxelPrintMode mode=VOXELPRINT_MATERIAL);
-	
-	void addArea(VoxelArea area);
+		m_data[m_area.index(p)] = n;
+		m_flags[m_area.index(p)] &= ~VOXELFLAG_NO_DATA;
+	}
+	// TODO: Should be removed and replaced with setNode
+	void setNodeNoRef(const v3s16 &p, const MapNode &n)
+	{
+		setNode(p, n);
+	}
 
 	/*
-		Copy data and set flags to 0
-		dst_area.getExtent() <= src_area.getExtent()
+		Set stuff if available without an emerge.
+		Return false if failed.
+		This is convenient but slower than playing around directly
+		with the m_data table with indices.
 	*/
-	void copyFrom(MapNode *src, VoxelArea src_area,
-			v3s16 from_pos, v3s16 to_pos, v3s16 size);
+	bool setNodeNoEmerge(const v3s16 &p, MapNode n)
+	{
+		if(!m_area.contains(p))
+			return false;
+		m_data[m_area.index(p)] = n;
+		return true;
+	}
 
 	/*
-		Algorithms
+		Control
 	*/
 
-	void clearFlag(u8 flag);
-	
-	void unspreadLight(enum LightBank bank, v3s16 p, u8 oldlight,
-			core::map<v3s16, bool> & light_sources);
-	void unspreadLight(enum LightBank bank,
-			core::map<v3s16, u8> & from_nodes,
-			core::map<v3s16, bool> & light_sources);
-	
-	void spreadLight(enum LightBank bank, v3s16 p);
-	void spreadLight(enum LightBank bank,
-			core::map<v3s16, bool> & from_nodes);
-	
-#if 0
-	// VOXELFLAG_CHECKED2s must usually be cleared before calling
-	// -1: dead end, 0-255: pressure
-	// highest_y: Highest found water y is stored here.
-	//            Must be initialized to -32768
-	int getWaterPressure(v3s16 p, s16 &highest_y, int recur_count);
+	virtual void clear();
 
-	/*
-		VOXELFLAG_CHECKED3s must usually be cleared before calling.
+	void print(std::ostream &o, const NodeDefManager *nodemgr,
+			VoxelPrintMode mode=VOXELPRINT_MATERIAL);
 
-		active_nodes: surface-touching air nodes with flow-causing
-		pressure. set-like dummy map container.
+	void addArea(const VoxelArea &area);
 
-		Spreads pressure pr at node p to request_area or as far as
-		there is invalid pressure.
-	*/
-	void spreadWaterPressure(v3s16 p, int pr,
-			VoxelArea request_area,
-			core::map<v3s16, u8> &active_nodes,
-			int recur_count);
-	
-	/*
-		VOXELFLAG_CHECKED3s must usually be cleared before calling.
-	*/
-	void updateAreaWaterPressure(VoxelArea a,
-			core::map<v3s16, u8> &active_nodes,
-			bool checked3_is_clear=false);
-	
 	/*
-		Returns true if moved something
+		Copy data and set flags to 0
+		dst_area.getExtent() <= src_area.getExtent()
 	*/
-	bool flowWater(v3s16 removed_pos,
-			core::map<v3s16, u8> &active_nodes,
-			int recursion_depth=0,
-			bool debugprint=false,
-			u32 stoptime=0
-	);
+	void copyFrom(MapNode *src, const VoxelArea& src_area,
+			v3s16 from_pos, v3s16 to_pos, const v3s16 &size);
 
-	/*
-		To flow some water, call this with the target node in
-		active_nodes
-		TODO: Make the active_nodes map to contain some vectors
-		      that are properly sorted according to water flow order.
-			  The current order makes water flow strangely if the
-			  first one is always taken.
-			  No, active_nodes should preserve the order stuff is
-			  added to it, in addition to adhering the water flow
-			  order.
-	*/
-	void flowWater(core::map<v3s16, u8> &active_nodes,
-			int recursion_depth=0,
-			bool debugprint=false,
-			u32 timelimit=50
-	);
-#endif
+	// Copy data
+	void copyTo(MapNode *dst, const VoxelArea& dst_area,
+			v3s16 dst_pos, v3s16 from_pos, const v3s16 &size);
 
 	/*
-		Virtual functions
+		Algorithms
 	*/
-	
-	/*
-		Get the contents of the requested area from somewhere.
-		Shall touch only nodes that have VOXELFLAG_NOT_LOADED
-		Shall reset VOXELFLAG_NOT_LOADED
 
-		If not found from source, add with VOXELFLAG_INEXISTENT
-	*/
-	virtual void emerge(VoxelArea a, s32 caller_id=-1)
-	{
-		//dstream<<"emerge p=("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
-		addArea(a);
-		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++)
-		{
-			s32 i = m_area.index(x,y,z);
-			// Don't touch nodes that have already been loaded
-			if(!(m_flags[i] & VOXELFLAG_NOT_LOADED))
-				continue;
-			m_flags[i] = VOXELFLAG_INEXISTENT;
-		}
-	}
+	void clearFlag(u8 flag);
 
 	/*
 		Member variables
@@ -504,30 +492,17 @@ class VoxelManipulator /*: public NodeContainer*/
 		MaxEdge is 1 higher than maximum allowed position
 	*/
 	VoxelArea m_area;
-	
+
 	/*
-		NULL if data size is 0 (extent (0,0,0))
+		nullptr if data size is 0 (extent (0,0,0))
 		Data is stored as [z*h*w + y*h + x]
 	*/
-	MapNode *m_data;
+	MapNode *m_data = nullptr;
 
 	/*
 		Flags of all nodes
 	*/
-	u8 *m_flags;
-	
-	//TODO: Use these or remove them
-	//TODO: Would these make any speed improvement?
-	//bool m_pressure_route_valid;
-	//v3s16 m_pressure_route_surface;
+	u8 *m_flags = nullptr;
 
-	/*
-		Some settings
-	*/
-	bool m_disable_water_climb;
-
-private:
+	static const MapNode ContentIgnoreNode;
 };
-
-#endif
-