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

1 files changed, 118 insertions, 102 deletions

diff --git a/src/mapblock_mesh.h b/src/mapblock_mesh.h
index 4d3e7d29d..5028873c4 100644
--- a/src/mapblock_mesh.h
+++ b/src/mapblock_mesh.h
@@ -21,9 +21,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define MAPBLOCK_MESH_HEADER
 
 #include "common_irrlicht.h"
-#include "mapblock_nodemod.h"
 #include "tile.h"
 #include "voxel.h"
+#include <map>
 
 class IGameDef;
 
@@ -31,127 +31,143 @@ class IGameDef;
 	Mesh making stuff
 */
 
-/*
-	This is used because CMeshBuffer::append() is very slow
-*/
-struct PreMeshBuffer
+
+class MapBlock;
+
+struct MeshMakeData
 {
-	video::SMaterial material;
-	core::array<u16> indices;
-	core::array<video::S3DVertex> vertices;
+	VoxelManipulator m_vmanip;
+	v3s16 m_blockpos;
+	v3s16 m_crack_pos_relative;
+	bool m_smooth_lighting;
+	IGameDef *m_gamedef;
+
+	MeshMakeData(IGameDef *gamedef);
+
+	/*
+		Copy central data directly from block, and other data from
+		parent of block.
+	*/
+	void fill(MapBlock *block);
+
+	/*
+		Set up with only a single node at (1,1,1)
+	*/
+	void fillSingleNode(MapNode *node);
+
+	/*
+		Set the (node) position of a crack
+	*/
+	void setCrack(int crack_level, v3s16 crack_pos);
+
+	/*
+		Enable or disable smooth lighting
+	*/
+	void setSmoothLighting(bool smooth_lighting);
 };
 
-class MeshCollector
+/*
+	Holds a mesh for a mapblock.
+
+	Besides the SMesh*, this contains information used for animating
+	the vertex positions, colors and texture coordinates of the mesh.
+	For example:
+	- cracks [implemented]
+	- day/night transitions [implemented]
+	- animated flowing liquids [not implemented]
+	- animating vertex positions for e.g. axles [not implemented]
+*/
+class MapBlockMesh
 {
 public:
-	void append(
-			video::SMaterial material,
-			const video::S3DVertex* const vertices,
-			u32 numVertices,
-			const u16* const indices,
-			u32 numIndices
-		)
+	// Builds the mesh given
+	MapBlockMesh(MeshMakeData *data);
+	~MapBlockMesh();
+
+	// Main animation function, parameters:
+	//   faraway: whether the block is far away from the camera (~50 nodes)
+	//   time: the global animation time, 0 .. 60 (repeats every minute)
+	//   daynight_ratio: 0 .. 1000
+	//   crack: -1 .. CRACK_ANIMATION_LENGTH-1 (-1 for off)
+	// Returns true if anything has been changed.
+	bool animate(bool faraway, float time, int crack, u32 daynight_ratio);
+
+	scene::SMesh* getMesh()
 	{
-		PreMeshBuffer *p = NULL;
-		for(u32 i=0; i<m_prebuffers.size(); i++)
-		{
-			PreMeshBuffer &pp = m_prebuffers[i];
-			if(pp.material != material)
-				continue;
-
-			p = &pp;
-			break;
-		}
-
-		if(p == NULL)
-		{
-			PreMeshBuffer pp;
-			pp.material = material;
-			m_prebuffers.push_back(pp);
-			p = &m_prebuffers[m_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]);
-		}
+		return m_mesh;
 	}
 
-	void fillMesh(scene::SMesh *mesh)
+	bool isAnimationForced() const
 	{
-		/*dstream<<"Filling mesh with "<<m_prebuffers.size()
-				<<" meshbuffers"<<std::endl;*/
-		for(u32 i=0; i<m_prebuffers.size(); i++)
-		{
-			PreMeshBuffer &p = m_prebuffers[i];
-
-			/*dstream<<"p.vertices.size()="<<p.vertices.size()
-					<<", p.indices.size()="<<p.indices.size()
-					<<std::endl;*/
-			
-			// Create meshbuffer
-			
-			// This is a "Standard MeshBuffer",
-			// it's a typedeffed CMeshBuffer<video::S3DVertex>
-			scene::SMeshBuffer *buf = new scene::SMeshBuffer();
-			// Set material
-			buf->Material = p.material;
-			//((scene::SMeshBuffer*)buf)->Material = p.material;
-			// Use VBO
-			//buf->setHardwareMappingHint(scene::EHM_STATIC);
-			// Add to mesh
-			mesh->addMeshBuffer(buf);
-			// Mesh grabbed it
-			buf->drop();
-
-			buf->append(p.vertices.pointer(), p.vertices.size(),
-					p.indices.pointer(), p.indices.size());
-		}
+		return m_animation_force_timer == 0;
+	}
+
+	void decreaseAnimationForceTimer()
+	{
+		if(m_animation_force_timer > 0)
+			m_animation_force_timer--;
 	}
 
 private:
-	core::array<PreMeshBuffer> m_prebuffers;
+	scene::SMesh *m_mesh;
+	IGameDef *m_gamedef;
+
+	// Must animate() be called before rendering?
+	bool m_has_animation;
+	int m_animation_force_timer;
+
+	// Animation info: cracks
+	// Last crack value passed to animate()
+	int m_last_crack;
+	// Maps mesh buffer (i.e. material) indices to base texture names
+	std::map<u32, std::string> m_crack_materials;
+
+	// Animation info: day/night transitions
+	// Last daynight_ratio value passed to animate()
+	u32 m_last_daynight_ratio;
+	// For each meshbuffer, maps vertex indices to (day,night) pairs
+	std::map<u32, std::map<u32, std::pair<u8, u8> > > m_daynight_diffs;
 };
 
-// Helper functions
-video::SColor MapBlock_LightColor(u8 alpha, u8 light);
-TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir,
-		NodeModMap *temp_mods, ITextureSource *tsrc, INodeDefManager *ndef);
 
-class MapBlock;
 
-struct MeshMakeData
+/*
+	This is used because CMeshBuffer::append() is very slow
+*/
+struct PreMeshBuffer
 {
-	u32 m_daynight_ratio;
-	NodeModMap m_temp_mods;
-	VoxelManipulator m_vmanip;
-	v3s16 m_blockpos;
-	
-	/*
-		Copy central data directly from block, and other data from
-		parent of block.
-	*/
-	void fill(u32 daynight_ratio, MapBlock *block);
+	TileSpec tile;
+	core::array<u16> indices;
+	core::array<video::S3DVertex> vertices;
+};
 
-	/*
-		Set up with only a single node at (1,1,1)
-	*/
-	void fillSingleNode(u32 daynight_ratio, MapNode *node);
+struct MeshCollector
+{
+	core::array<PreMeshBuffer> prebuffers;
+
+	void append(const TileSpec &material,
+			const video::S3DVertex *vertices, u32 numVertices,
+			const u16 *indices, u32 numIndices);
 };
 
-// This is the highest-level function in here
-scene::SMesh* makeMapBlockMesh(MeshMakeData *data, IGameDef *gamedef);
+// This encodes
+//   alpha in the A channel of the returned SColor
+//   day light (0-255) in the R channel of the returned SColor
+//   night light (0-255) in the G channel of the returned SColor
+inline video::SColor MapBlock_LightColor(u8 alpha, u16 light)
+{
+	return video::SColor(alpha, (light & 0xff), (light >> 8), 0);
+}
+
+// Compute light at node
+u16 getInteriorLight(MapNode n, s32 increment, MeshMakeData *data);
+u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, MeshMakeData *data);
+u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data);
+
+// Retrieves the TileSpec of a face of a node
+// Adds MATERIAL_FLAG_CRACK if the node is cracked
+TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data);
+TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data);
 
 #endif