X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock.h;h=22b3b7db6189d986c947d9ac50c393f4f53fe909;hb=fe98fe342a65c995bbc59470549417f38311366b;hp=48f8775519fe8e47b713dba47e43beda4a6c9b2e;hpb=c707e00195f1035ae535f3fc8697af42e73190c0;p=minetest.git

diff --git a/src/mapblock.h b/src/mapblock.h
index 48f877551..22b3b7db6 100644
--- a/src/mapblock.h
+++ b/src/mapblock.h
@@ -1,5 +1,20 @@
 /*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
+Minetest-c55
+Copyright (C) 2010 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
+(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.
+
+You should have received a copy of the GNU 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 MAPBLOCK_HEADER
@@ -14,11 +29,19 @@
 #include "exceptions.h"
 #include "serialization.h"
 #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
+
+class Map;
 
-#define MAP_BLOCKSIZE 16
+#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
 
-// Named by looking towards z+
+/*// Named by looking towards z+
 enum{
 	FACE_BACK=0,
 	FACE_TOP,
@@ -26,14 +49,39 @@ enum{
 	FACE_FRONT,
 	FACE_BOTTOM,
 	FACE_LEFT
-};
+};*/
 
-struct FastFace
+enum ModifiedState
 {
-	u8 material;
-	video::S3DVertex vertices[4]; // Precalculated vertices
+	// Has not been modified.
+	MOD_STATE_CLEAN = 0,
+	MOD_RESERVED1 = 1,
+	// Has been modified, and will be saved when being unloaded.
+	MOD_STATE_WRITE_AT_UNLOAD = 2,
+	MOD_RESERVED3 = 3,
+	// Has been modified, and will be saved as soon as possible.
+	MOD_STATE_WRITE_NEEDED = 4,
+	MOD_RESERVED5 = 5,
 };
 
+// NOTE: If this is enabled, set MapBlock to be initialized with
+//       CONTENT_IGNORE.
+/*enum BlockGenerationStatus
+{
+	// Completely non-generated (filled with CONTENT_IGNORE).
+	BLOCKGEN_UNTOUCHED=0,
+	// Trees or similar might have been blitted from other blocks to here.
+	// Otherwise, the block contains CONTENT_IGNORE
+	BLOCKGEN_FROM_NEIGHBORS=2,
+	// Has been generated, but some neighbors might put some stuff in here
+	// when they are generated.
+	// Does not contain any CONTENT_IGNORE
+	BLOCKGEN_SELF_GENERATED=4,
+	// The block and all its neighbors have been generated
+	BLOCKGEN_FULLY_GENERATED=6
+};*/
+
+#if 0
 enum
 {
 	NODECONTAINER_ID_MAPBLOCK,
@@ -50,139 +98,177 @@ 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);
+		}
+	}
 };
+#endif
 
-class MapBlock : public NodeContainer
-{
-private:
+/*
+	MapBlock itself
+*/
 
-	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.
-	*/
-	bool changed;
-	/*
-		Used for some initial lighting stuff.
-		At least /has been/ used. 8)
-	*/
-	bool is_underground;
-	
-	MapBlockObjectList m_objects;
-	
+class MapBlock /*: public NodeContainer*/
+{
 public:
-
-	/*
-		This used by Server's block creation stuff for not sending
-		blocks that are waiting a lighting update.
-
-		If true, the block needs some work by the one who set this
-		to true.
-
-		While true, nobody else should touch the block.
-	*/
-	//bool is_incomplete;
-	
-	scene::SMesh *mesh;
-	JMutex mesh_mutex;
-
-	MapBlock(NodeContainer *parent, v3s16 pos, bool dummy=false):
-			m_parent(parent),
-			m_pos(pos),
-			changed(true),
-			is_underground(false),
-			m_objects(this)
-			//is_incomplete(false)
-	{
-		data = NULL;
-		if(dummy == false)
-			reallocate();
-		mesh_mutex.Init();
-		mesh = NULL;
-	}
-
-	~MapBlock()
-	{
-		{
-			JMutexAutoLock lock(mesh_mutex);
-			
-			if(mesh != NULL)
-			{
-				mesh->drop();
-				mesh = NULL;
-			}
-		}
-
-		if(data)
-			delete[] data;
-	}
+	MapBlock(Map *parent, v3s16 pos, bool dummy=false);
+	~MapBlock();
 	
-	virtual u16 nodeContainerId() const
+	/*virtual u16 nodeContainerId() const
 	{
 		return NODECONTAINER_ID_MAPBLOCK;
+	}*/
+	
+	Map * getParent()
+	{
+		return m_parent;
 	}
 
-	NodeContainer * getParent()
+	void reallocate()
 	{
-		return m_parent;
+		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();
+			data[i] = MapNode(CONTENT_IGNORE);
+		}
+		raiseModified(MOD_STATE_WRITE_NEEDED);
 	}
 
+	/*
+		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.
+	*/
+	// DEPRECATED, use *Modified()
+	void setChangedFlag()
 	{
-		return changed;
+		//dstream<<"Deprecated setChangedFlag() called"<<std::endl;
+		raiseModified(MOD_STATE_WRITE_NEEDED);
 	}
-
+	// DEPRECATED, use *Modified()
 	void resetChangedFlag()
 	{
-		changed = false;
+		//dstream<<"Deprecated resetChangedFlag() called"<<std::endl;
+		resetModified();
 	}
-
-	void setChangedFlag()
+	// DEPRECATED, use *Modified()
+	bool getChangedFlag()
 	{
-		changed = true;
+		//dstream<<"Deprecated getChangedFlag() called"<<std::endl;
+		if(getModified() == MOD_STATE_CLEAN)
+			return false;
+		else
+			return true;
 	}
-
-	v3s16 getPos()
+	
+	// m_modified methods
+	void raiseModified(u32 mod)
 	{
-		return m_pos;
+		m_modified = MYMAX(m_modified, mod);
 	}
-		
-	v3s16 getPosRelative()
+	u32 getModified()
 	{
-		return m_pos * MAP_BLOCKSIZE;
+		return m_modified;
 	}
-		
+	void resetModified()
+	{
+		m_modified = MOD_STATE_CLEAN;
+	}
+	
+	// is_underground getter/setter
 	bool getIsUnderground()
 	{
 		return is_underground;
 	}
-
 	void setIsUnderground(bool a_is_underground)
 	{
 		is_underground = a_is_underground;
-		setChangedFlag();
+		raiseModified(MOD_STATE_WRITE_NEEDED);
+	}
+
+#ifndef SERVER
+	void setMeshExpired(bool expired)
+	{
+		m_mesh_expired = expired;
+	}
+	
+	bool getMeshExpired()
+	{
+		return m_mesh_expired;
+	}
+#endif
+
+	void setLightingExpired(bool expired)
+	{
+		if(expired != m_lighting_expired){
+			m_lighting_expired = expired;
+			raiseModified(MOD_STATE_WRITE_NEEDED);
+		}
+	}
+	bool getLightingExpired()
+	{
+		return m_lighting_expired;
+	}
+
+	bool isGenerated()
+	{
+		return m_generated;
+	}
+	void setGenerated(bool b)
+	{
+		if(b != m_generated){
+			raiseModified(MOD_STATE_WRITE_NEEDED);
+			m_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(),
@@ -190,19 +276,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)
@@ -212,10 +290,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)
@@ -231,6 +305,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)
@@ -239,7 +322,7 @@ class MapBlock : public NodeContainer
 		if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 		if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
 		data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
-		setChangedFlag();
+		raiseModified(MOD_STATE_WRITE_NEEDED);
 	}
 	
 	void setNode(v3s16 p, MapNode & n)
@@ -268,7 +351,7 @@ class MapBlock : public NodeContainer
 		if(data == NULL)
 			throw InvalidPositionException();
 		data[z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + y*MAP_BLOCKSIZE + x] = n;
-		setChangedFlag();
+		raiseModified(MOD_STATE_WRITE_NEEDED);
 	}
 	
 	void setNodeNoCheck(v3s16 p, MapNode & n)
@@ -283,6 +366,7 @@ class MapBlock : public NodeContainer
 	bool isValidPositionParent(v3s16 p);
 	MapNode getNodeParent(v3s16 p);
 	void setNodeParent(v3s16 p, MapNode & n);
+	MapNode getNodeParentNoEx(v3s16 p);
 
 	void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
 	{
@@ -292,103 +376,176 @@ class MapBlock : public NodeContainer
 					setNode(x0+x, y0+y, z0+z, node);
 	}
 
-	static FastFace * makeFastFace(u8 material, u8 light, v3f p,
-			v3f dir, v3f scale, v3f posRelative_f);
-	
-	u8 getFaceLight(v3s16 p, v3s16 face_dir);
-	
 	/*
-		Gets node material from any place relative to block.
-		Returns MATERIAL_AIR if doesn't exist.
+		Graphics-related methods
 	*/
-	u8 getNodeMaterial(v3s16 p);
+	
+	/*// 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),
+				getNodeParentNoEx(p + face_dir),
+				face_dir);
+	}
+	
+#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(v3s16 startpos,
-			u16 length,
-			v3s16 translate_dir,
-			v3s16 face_dir,
-			core::list<FastFace*> &dest);
-
-	void updateMesh();
-
-	bool propagateSunlight(core::map<v3s16, bool> & light_sources);
+	void updateMesh(u32 daynight_ratio);
+#endif
+	// Replace the mesh with a new one
+	void replaceMesh(scene::SMesh *mesh_new);
+#endif
 	
-	// Doesn't write version by itself
-	void serialize(std::ostream &os, u8 version);
-
-	void deSerialize(std::istream &is, u8 version);
+	// See comments in mapblock.cpp
+	bool propagateSunlight(core::map<v3s16, bool> & light_sources,
+			bool remove_light=false, bool *black_air_left=NULL);
 	
-	void serializeObjects(std::ostream &os, u8 version)
+	// Copies data to VoxelManipulator to getPosRelative()
+	void copyTo(VoxelManipulator &dst);
+	// Copies data from VoxelManipulator getPosRelative()
+	void copyFrom(VoxelManipulator &dst);
+
+#ifndef SERVER // Only on client
+	/*
+		Methods for setting temporary modifications to nodes for
+		drawing
+
+		returns true if the mod was different last time
+	*/
+	bool setTempMod(v3s16 p, const NodeMod &mod)
 	{
-		m_objects.serialize(os, version);
+		/*dstream<<"setTempMod called on block"
+				<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+				<<", mod.type="<<mod.type
+				<<", mod.param="<<mod.param
+				<<std::endl;*/
+		JMutexAutoLock lock(m_temp_mods_mutex);
+
+		return m_temp_mods.set(p, mod);
 	}
-	// If smgr!=NULL, new objects are added to the scene
-	void updateObjects(std::istream &is, u8 version,
-			scene::ISceneManager *smgr)
+	// Returns true if there was one
+	bool getTempMod(v3s16 p, NodeMod *mod)
 	{
-		m_objects.update(is, version, smgr);
+		JMutexAutoLock lock(m_temp_mods_mutex);
 
-		setChangedFlag();
+		return m_temp_mods.get(p, mod);
 	}
-	void clearObjects()
+	bool clearTempMod(v3s16 p)
 	{
-		m_objects.clear();
+		JMutexAutoLock lock(m_temp_mods_mutex);
 
-		setChangedFlag();
+		return m_temp_mods.clear(p);
 	}
-	void addObject(MapBlockObject *object)
-			throw(ContainerFullException, AlreadyExistsException)
+	bool clearTempMods()
 	{
-		m_objects.add(object);
-
-		setChangedFlag();
+		JMutexAutoLock lock(m_temp_mods_mutex);
+		
+		return m_temp_mods.clear();
 	}
-	void removeObject(s16 id)
+	void copyTempMods(NodeModMap &dst)
 	{
-		m_objects.remove(id);
+		JMutexAutoLock lock(m_temp_mods_mutex);
+		m_temp_mods.copy(dst);
+	}
+#endif
+
+	/*
+		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
+		update between day and night, the neighboring blocks have
+		to be taken into account. Use Map::dayNightDiffed().
+	*/
+	void updateDayNightDiff();
 
-		setChangedFlag();
+	bool dayNightDiffed()
+	{
+		return m_day_night_differs;
 	}
-	MapBlockObject * getObject(s16 id)
+
+	/*
+		Miscellaneous stuff
+	*/
+	
+	/*
+		Tries to measure ground level.
+		Return value:
+			-1 = only air
+			-2 = only ground
+			-3 = random fail
+			0...MAP_BLOCKSIZE-1 = ground level
+	*/
+	s16 getGroundLevel(v2s16 p2d);
+
+	/*
+		Timestamp (see m_timestamp)
+		NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
+	*/
+	void setTimestamp(u32 time)
 	{
-		return m_objects.get(id);
+		m_timestamp = time;
+		raiseModified(MOD_STATE_WRITE_AT_UNLOAD);
 	}
-	JMutexAutoLock * getObjectLock()
+	void setTimestampNoChangedFlag(u32 time)
 	{
-		return m_objects.getLock();
+		m_timestamp = time;
 	}
-	void stepObjects(float dtime, bool server)
+	u32 getTimestamp()
 	{
-		m_objects.step(dtime, server);
-
-		setChangedFlag();
+		return m_timestamp;
 	}
-
-	/*void wrapObject(MapBlockObject *object)
+	
+	/*
+		See m_usage_timer
+	*/
+	void resetUsageTimer()
 	{
-		m_objects.wrapObject(object);
-
-		setChangedFlag();
-	}*/
-
-	// origin is relative to block
-	void getObjects(v3f origin, f32 max_d,
-			core::array<DistanceSortedObject> &dest)
+		m_usage_timer = 0;
+	}
+	void incrementUsageTimer(float dtime)
 	{
-		m_objects.getObjects(origin, max_d, dest);
+		m_usage_timer += dtime;
 	}
-
-	s32 getObjectCount()
+	u32 getUsageTimer()
 	{
-		return m_objects.getCount();
+		return m_usage_timer;
 	}
 
+	/*
+		Serialization
+	*/
+	
+	// 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:
+	/*
+		Private methods
+	*/
 
 	/*
 		Used only internally, because changes can't be tracked
@@ -396,6 +553,8 @@ class MapBlock : public NodeContainer
 
 	MapNode & getNodeRef(s16 x, s16 y, s16 z)
 	{
+		if(data == NULL)
+			throw InvalidPositionException();
 		if(x < 0 || x >= MAP_BLOCKSIZE) throw InvalidPositionException();
 		if(y < 0 || y >= MAP_BLOCKSIZE) throw InvalidPositionException();
 		if(z < 0 || z >= MAP_BLOCKSIZE) throw InvalidPositionException();
@@ -405,6 +564,92 @@ 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
+	Map *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 server, this is used for telling whether the
+		  block has been modified from the one on disk.
+		- On the client, this is used for nothing.
+	*/
+	u32 m_modified;
+
+	/*
+		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;
+
+	bool m_generated;
+	
+#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
+	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;
+
+	/*
+		When the block is accessed, this is set to 0.
+		Map will unload the block when this reaches a timeout.
+	*/
+	float m_usage_timer;
 };
 
 inline bool blockpos_over_limit(v3s16 p)
@@ -436,5 +681,10 @@ inline s16 getNodeBlockY(s16 y)
 	return getContainerPos(y, MAP_BLOCKSIZE);
 }
 
+/*
+	Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block);
+
 #endif