X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=ca36499acaa87930cd93230226ce9db1f8016078;hb=30c34cc23e9a060ef964854038a314a94ad5cbae;hp=743dad9276fdd647f6bf82ea10bce6b0f7b9a462;hpb=847a4227b850bc943d11c5b8191fb6bcbce1920a;p=dragonfireclient.git

diff --git a/src/mapblock.h b/src/mapblock.h
index 743dad927..ca36499ac 100644
--- a/src/mapblock.h
+++ b/src/mapblock.h
@@ -31,10 +31,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "constants.h"
 #include "mapblockobject.h"
 #include "voxel.h"
+#include "nodemetadata.h"
+#include "staticobject.h"
+#include "mapblock_nodemod.h"
+#ifndef SERVER
+	#include "mapblock_mesh.h"
+#endif
 
-#define MAP_BLOCKSIZE 16
 
-// Named by looking towards z+
+#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
+
+/*// Named by looking towards z+
 enum{
 	FACE_BACK=0,
 	FACE_TOP,
@@ -42,31 +49,7 @@ enum{
 	FACE_FRONT,
 	FACE_BOTTOM,
 	FACE_LEFT
-};
-
-struct FastFace
-{
-	TileSpec tile;
-	video::S3DVertex vertices[4]; // Precalculated vertices
-};
-
-enum NodeModType
-{
-	NODEMOD_NONE,
-	NODEMOD_CHANGECONTENT, //param is content id
-	NODEMOD_CRACK // param is crack progression
-};
-
-struct NodeMod
-{
-	NodeMod(enum NodeModType a_type=NODEMOD_NONE, u16 a_param=0)
-	{
-		type = a_type;
-		param = a_param;
-	}
-	enum NodeModType type;
-	u16 param;
-};
+};*/
 
 enum
 {
@@ -84,8 +67,22 @@ class NodeContainer
 	virtual MapNode getNode(v3s16 p) = 0;
 	virtual void setNode(v3s16 p, MapNode & n) = 0;
 	virtual u16 nodeContainerId() const = 0;
+
+	MapNode getNodeNoEx(v3s16 p)
+	{
+		try{
+			return getNode(p);
+		}
+		catch(InvalidPositionException &e){
+			return MapNode(CONTENT_IGNORE);
+		}
+	}
 };
 
+/*
+	MapBlock itself
+*/
+
 class MapBlock : public NodeContainer
 {
 public:
@@ -96,37 +93,66 @@ class MapBlock : public NodeContainer
 	{
 		return NODECONTAINER_ID_MAPBLOCK;
 	}
-
+	
 	NodeContainer * getParent()
 	{
 		return m_parent;
 	}
 
+	void reallocate()
+	{
+		if(data != NULL)
+			delete[] data;
+		u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
+		data = new MapNode[l];
+		for(u32 i=0; i<l; i++){
+			data[i] = MapNode();
+		}
+		setChangedFlag();
+	}
+
+	/*
+		Flags
+	*/
+
 	bool isDummy()
 	{
 		return (data == NULL);
 	}
-
 	void unDummify()
 	{
 		assert(isDummy());
 		reallocate();
 	}
 	
-	bool getChangedFlag()
+	/*
+		This is called internally or externally after the block is
+		modified, so that the block is saved and possibly not deleted from
+		memory.
+	*/
+	void setChangedFlag()
 	{
-		return changed;
+		changed = true;
 	}
-
 	void resetChangedFlag()
 	{
 		changed = false;
 	}
+	bool getChangedFlag()
+	{
+		return changed;
+	}
 
-	void setChangedFlag()
+	bool getIsUnderground()
 	{
-		changed = true;
+		return is_underground;
 	}
+	void setIsUnderground(bool a_is_underground)
+	{
+		is_underground = a_is_underground;
+		setChangedFlag();
+	}
+
 #ifndef SERVER
 	void setMeshExpired(bool expired)
 	{
@@ -138,27 +164,50 @@ class MapBlock : public NodeContainer
 		return m_mesh_expired;
 	}
 #endif
-	v3s16 getPos()
+
+	void setLightingExpired(bool expired)
 	{
-		return m_pos;
+		m_lighting_expired = expired;
+		setChangedFlag();
 	}
-		
-	v3s16 getPosRelative()
+	bool getLightingExpired()
 	{
-		return m_pos * MAP_BLOCKSIZE;
+		return m_lighting_expired;
 	}
-		
-	bool getIsUnderground()
+
+	/*bool isFullyGenerated()
 	{
-		return is_underground;
+		return !m_not_fully_generated;
 	}
-
-	void setIsUnderground(bool a_is_underground)
+	void setFullyGenerated(bool b)
 	{
-		is_underground = a_is_underground;
 		setChangedFlag();
+		m_not_fully_generated = !b;
+	}*/
+
+	bool isValid()
+	{
+		if(m_lighting_expired)
+			return false;
+		if(data == NULL)
+			return false;
+		return true;
 	}
 
+	/*
+		Position stuff
+	*/
+
+	v3s16 getPos()
+	{
+		return m_pos;
+	}
+		
+	v3s16 getPosRelative()
+	{
+		return m_pos * MAP_BLOCKSIZE;
+	}
+		
 	core::aabbox3d<s16> getBox()
 	{
 		return core::aabbox3d<s16>(getPosRelative(),
@@ -166,19 +215,11 @@ class MapBlock : public NodeContainer
 				+ v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
 				- v3s16(1,1,1));
 	}
-	
-	void reallocate()
-	{
-		if(data != NULL)
-			delete[] data;
-		u32 l = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
-		data = new MapNode[l];
-		for(u32 i=0; i<l; i++){
-			data[i] = MapNode();
-		}
-		setChangedFlag();
-	}
 
+	/*
+		Regular MapNode get-setters
+	*/
+	
 	bool isValidPosition(v3s16 p)
 	{
 		if(data == NULL)
@@ -188,10 +229,6 @@ class MapBlock : public NodeContainer
 				&& p.Z >= 0 && p.Z < MAP_BLOCKSIZE);
 	}
 
-	/*
-		Regular MapNode get-setters
-	*/
-	
 	MapNode getNode(s16 x, s16 y, s16 z)
 	{
 		if(data == NULL)
@@ -207,6 +244,15 @@ class MapBlock : public NodeContainer
 		return getNode(p.X, p.Y, p.Z);
 	}
 	
+	MapNode getNodeNoEx(v3s16 p)
+	{
+		try{
+			return getNode(p.X, p.Y, p.Z);
+		}catch(InvalidPositionException &e){
+			return MapNode(CONTENT_IGNORE);
+		}
+	}
+	
 	void setNode(s16 x, s16 y, s16 z, MapNode & n)
 	{
 		if(data == NULL)
@@ -269,10 +315,22 @@ class MapBlock : public NodeContainer
 					setNode(x0+x, y0+y, z0+z, node);
 	}
 
-	u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
-			v3s16 face_dir);
+	/*
+		Graphics-related methods
+	*/
 	
+	/*// A quick version with nodes passed as parameters
+	u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
+			v3s16 face_dir);*/
+	/*// A more convenient version
 	u8 getFaceLight(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
+	{
+		return getFaceLight(daynight_ratio,
+				getNodeParentNoEx(p),
+				getNodeParentNoEx(p + face_dir),
+				face_dir);
+	}*/
+	u8 getFaceLight2(u32 daynight_ratio, v3s16 p, v3s16 face_dir)
 	{
 		return getFaceLight(daynight_ratio,
 				getNodeParentNoEx(p),
@@ -280,51 +338,38 @@ class MapBlock : public NodeContainer
 				face_dir);
 	}
 	
-#ifndef SERVER
-	// light = 0...255
-	static void makeFastFace(TileSpec tile, u8 light, v3f p,
-			v3s16 dir, v3f scale, v3f posRelative_f,
-			core::array<FastFace> &dest);
-	
-	TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir);
-	u8 getNodeContent(v3s16 p, MapNode mn);
+#ifndef SERVER // Only on client
 
+#if 1
 	/*
-		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
+		Thread-safely updates the whole mesh of the mapblock.
+		NOTE: Prefer generating the mesh separately and then using
+		replaceMesh().
 	*/
-	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);
-
 	void updateMesh(u32 daynight_ratio);
-	/*void updateMesh(s32 daynight_i);
-	// Updates all DAYNIGHT_CACHE_COUNT meshes
-	void updateMeshes(s32 first_i=0);*/
-#endif // !SERVER
+#endif
+	// Replace the mesh with a new one
+	void replaceMesh(scene::SMesh *mesh_new);
+#endif
 	
 	// See comments in mapblock.cpp
-	bool propagateSunlight(core::map<v3s16, bool> & light_sources);
+	bool propagateSunlight(core::map<v3s16, bool> & light_sources,
+			bool remove_light=false, bool *black_air_left=NULL);
 	
 	// Copies data to VoxelManipulator to getPosRelative()
 	void copyTo(VoxelManipulator &dst);
+	// Copies data from VoxelManipulator getPosRelative()
+	void copyFrom(VoxelManipulator &dst);
 
 	/*
-		Object stuff
+		MapBlockObject stuff
+		DEPRECATED
 	*/
 	
-	void serializeObjects(std::ostream &os, u8 version)
+	/*void serializeObjects(std::ostream &os, u8 version)
 	{
 		m_objects.serialize(os, version);
-	}
+	}*/
 	// If smgr!=NULL, new objects are added to the scene
 	void updateObjects(std::istream &is, u8 version,
 			scene::ISceneManager *smgr, u32 daynight_ratio)
@@ -366,13 +411,6 @@ class MapBlock : public NodeContainer
 	*/
 	void stepObjects(float dtime, bool server, u32 daynight_ratio);
 
-	/*void wrapObject(MapBlockObject *object)
-	{
-		m_objects.wrapObject(object);
-
-		setChangedFlag();
-	}*/
-
 	// origin is relative to block
 	void getObjects(v3f origin, f32 max_d,
 			core::array<DistanceSortedObject> &dest)
@@ -380,20 +418,19 @@ class MapBlock : public NodeContainer
 		m_objects.getObjects(origin, max_d, dest);
 	}
 
-	/*void getPseudoObjects(v3f origin, f32 max_d,
-			core::array<DistanceSortedObject> &dest);*/
-
 	s32 getObjectCount()
 	{
 		return m_objects.getCount();
 	}
 
-#ifndef SERVER
+#ifndef SERVER // Only on client
 	/*
 		Methods for setting temporary modifications to nodes for
 		drawing
+
+		returns true if the mod was different last time
 	*/
-	void setTempMod(v3s16 p, NodeMod mod)
+	bool setTempMod(v3s16 p, const NodeMod &mod)
 	{
 		/*dstream<<"setTempMod called on block"
 				<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
@@ -401,35 +438,39 @@ class MapBlock : public NodeContainer
 				<<", mod.param="<<mod.param
 				<<std::endl;*/
 		JMutexAutoLock lock(m_temp_mods_mutex);
-		m_temp_mods[p] = mod;
+
+		return m_temp_mods.set(p, mod);
 	}
 	// Returns true if there was one
-	bool getTempMod(v3s16 p, struct NodeMod *mod)
+	bool getTempMod(v3s16 p, NodeMod *mod)
 	{
 		JMutexAutoLock lock(m_temp_mods_mutex);
-		core::map<v3s16, NodeMod>::Node *n;
-		n = m_temp_mods.find(p);
-		if(n == NULL)
-			return false;
-		if(mod)
-			*mod = n->getValue();
-		return true;
+
+		return m_temp_mods.get(p, mod);
 	}
-	void clearTempMod(v3s16 p)
+	bool clearTempMod(v3s16 p)
 	{
 		JMutexAutoLock lock(m_temp_mods_mutex);
-		if(m_temp_mods.find(p))
-			m_temp_mods.remove(p);
+
+		return m_temp_mods.clear(p);
 	}
-	void clearTempMods()
+	bool clearTempMods()
 	{
 		JMutexAutoLock lock(m_temp_mods_mutex);
-		m_temp_mods.clear();
+		
+		return m_temp_mods.clear();
+	}
+	void copyTempMods(NodeModMap &dst)
+	{
+		JMutexAutoLock lock(m_temp_mods_mutex);
+		m_temp_mods.copy(dst);
 	}
 #endif
 
 	/*
-		Day-night lighting difference
+		Update day-night lighting difference flag.
+		
+		Sets m_day_night_differs to appropriate value.
 		
 		These methods don't care about neighboring blocks.
 		It means that to know if a block really doesn't need a mesh
@@ -457,27 +498,40 @@ class MapBlock : public NodeContainer
 	*/
 	s16 getGroundLevel(v2s16 p2d);
 
+	/*
+		Timestamp (see m_timestamp)
+		NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
+	*/
+	void setTimestamp(u32 time)
+	{
+		m_timestamp = time;
+		setChangedFlag();
+	}
+	void setTimestampNoChangedFlag(u32 time)
+	{
+		m_timestamp = time;
+	}
+	u32 getTimestamp()
+	{
+		return m_timestamp;
+	}
+
 	/*
 		Serialization
 	*/
 	
-	// Doesn't write version by itself
+	// These don't write or read version by itself
 	void serialize(std::ostream &os, u8 version);
-
 	void deSerialize(std::istream &is, u8 version);
+	// Used after the basic ones when writing on disk (serverside)
+	void serializeDiskExtra(std::ostream &os, u8 version);
+	void deSerializeDiskExtra(std::istream &is, u8 version);
 
+private:
 	/*
-		Public member variables
+		Private methods
 	*/
 
-#ifndef SERVER
-	//scene::SMesh *mesh[DAYNIGHT_CACHE_COUNT];
-	scene::SMesh *mesh;
-	JMutex mesh_mutex;
-#endif
-
-private:
-
 	/*
 		Used only internally, because changes can't be tracked
 	*/
@@ -496,45 +550,86 @@ class MapBlock : public NodeContainer
 		return getNodeRef(p.X, p.Y, p.Z);
 	}
 
+public:
+	/*
+		Public member variables
+	*/
+
+#ifndef SERVER // Only on client
+	scene::SMesh *mesh;
+	JMutex mesh_mutex;
+#endif
+	
+	NodeMetadataList m_node_metadata;
+	StaticObjectList m_static_objects;
 	
+private:
+	/*
+		Private member variables
+	*/
+
+	// NOTE: Lots of things rely on this being the Map
 	NodeContainer *m_parent;
 	// Position in blocks on parent
 	v3s16 m_pos;
+	
 	/*
 		If NULL, block is a dummy block.
 		Dummy blocks are used for caching not-found-on-disk blocks.
 	*/
 	MapNode * data;
+
 	/*
-		- On the client, this is used for checking whether to
-		  recalculate the face cache. (Is it anymore?)
 		- On the server, this is used for telling whether the
 		  block has been changed from the one on disk.
+		- On the client, this is used for nothing.
 	*/
 	bool changed;
+
 	/*
-		Used for some initial lighting stuff.
-		At least /has been/ used. 8)
-		It's probably useless now.
+		When propagating sunlight and the above block doesn't exist,
+		sunlight is assumed if this is false.
+
+		In practice this is set to true if the block is completely
+		undeground with nothing visible above the ground except
+		caves.
 	*/
 	bool is_underground;
+
+	/*
+		Set to true if changes has been made that make the old lighting
+		values wrong but the lighting hasn't been actually updated.
+
+		If this is false, lighting is exactly right.
+		If this is true, lighting might be wrong or right.
+	*/
+	bool m_lighting_expired;
 	
 	// Whether day and night lighting differs
 	bool m_day_night_differs;
 	
+	// DEPRECATED
 	MapBlockObjectList m_objects;
 
-	// Object spawning stuff
-	float m_spawn_timer;
-	
-#ifndef SERVER
+#ifndef SERVER // Only on client
+	/*
+		Set to true if the mesh has been ordered to be updated
+		sometime in the background.
+		In practice this is set when the day/night lighting switches.
+	*/
 	bool m_mesh_expired;
 	
 	// Temporary modifications to nodes
 	// These are only used when drawing
-	core::map<v3s16, NodeMod> m_temp_mods;
+	NodeModMap m_temp_mods;
 	JMutex m_temp_mods_mutex;
 #endif
+	
+	/*
+		When block is removed from active blocks, this is set to gametime.
+		Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
+	*/
+	u32 m_timestamp;
 };
 
 inline bool blockpos_over_limit(v3s16 p)