1 files changed, 333 insertions, 0 deletions

diff --git a/Tools/BiomeVisualiser/BiomeCache.cpp b/Tools/BiomeVisualiser/BiomeCache.cpp
new file mode 100644
index 000000000..12133b8b6
--- /dev/null
+++ b/Tools/BiomeVisualiser/BiomeCache.cpp
@@ -0,0 +1,333 @@
+

+// BiomeCache.cpp

+

+// Implements the cBiomeCache class representing a biome source that caches data from the underlying biome source

+

+#include "Globals.h"

+#include "BiomeCache.h"

+#include "Timer.h"

+

+

+

+

+

+static int GetNumCores(void)

+{

+	// Get number of cores by querying the system process affinity mask

+	DWORD Affinity, ProcAffinity;

+	GetProcessAffinityMask(GetCurrentProcess(), &ProcAffinity, &Affinity);

+	int NumCores = 0;

+	while (Affinity > 0)

+	{

+		if ((Affinity & 1) == 1)

+		{

+			NumCores++;

+		}

+		Affinity >>= 1;

+	}  // while (Affinity > 0)

+	return NumCores;

+}

+

+

+

+

+

+cBiomeCache::cBiomeCache(void) :

+	m_Source(NULL),

+	m_BaseX(-100000),

+	m_BaseZ(-100000),

+	m_Available(NULL),

+	m_IsTerminatingThreads(false)

+{

+	int NumThreads = GetNumCores();

+	NumThreads--;  // One core should be left for the system to run on ;)

+	for (int i = NumThreads; i > 0; i--)

+	{

+		cThread * Thread = new cThread(*this);

+		m_Threads.push_back(Thread);

+		Thread->Start();

+	}

+}

+

+

+

+

+cBiomeCache::~cBiomeCache()

+{

+	m_IsTerminatingThreads = true;

+	for (cThreads::iterator itr = m_Threads.begin(), end = m_Threads.end(); itr != end; ++itr)

+	{

+		m_evtQueued.Set();

+	}

+	for (cThreads::iterator itr = m_Threads.begin(), end = m_Threads.end(); itr != end; ++itr)

+	{

+		delete *itr;

+	}

+	m_Threads.clear();

+	

+	SetSource(NULL);

+}

+

+

+

+

+

+cBiomeSource::eAvailability cBiomeCache::GetBiome(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_Biomes)

+{

+	if (m_Source == NULL)

+	{

+		return baNever;

+	}

+

+	// Look up using the cache:

+	int x = a_ChunkX - m_BaseX;

+	int z = a_ChunkZ - m_BaseZ;

+	if ((x < 0) || (x >= m_Width) || (z < 0) || (z >= m_Height))

+	{

+		// Outside the cached region

+		return baNever;

+	}

+	

+	cCSLock Lock(m_CS);

+	cItem * Item = m_Available[x + m_Width * z];

+	if (Item == NULL)

+	{

+		// Item hasn't been processed yet

+		return baLater;

+	}

+	if (Item->m_IsValid)

+	{

+		memcpy(a_Biomes, Item->m_Biomes, sizeof(a_Biomes));

+		return baNow;

+	}

+

+	// Item has been processed, but the underlying source refused to give the data to us

+	return baNever;

+}

+

+

+

+

+

+void cBiomeCache::HintViewArea(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ)

+{

+	cTimer Timer("Cache: HintViewArea");

+	

+	if (

+		(a_MinChunkX == m_BaseX) && 

+		(a_MaxChunkX == m_BaseX + m_Width - 1) &&

+		(a_MinChunkZ == m_BaseZ) &&

+		(a_MaxChunkZ == m_BaseZ + m_Height - 1)

+	)

+	{

+		// The same set of parameters, bail out

+		return;

+	}

+	

+	if (m_Source != NULL)

+	{

+		m_Source->HintViewArea(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ);

+	}

+	

+	int NewWidth  = a_MaxChunkX - a_MinChunkX + 1;

+	int NewHeight = a_MaxChunkZ - a_MinChunkZ + 1;

+	

+	// Make a new empty cache table:

+	pItem * NewAvailable = new pItem[NewWidth * NewHeight];

+	for (int i = NewWidth * NewHeight - 1; i >= 0; --i)

+	{

+		NewAvailable[i] = NULL;

+	}

+

+	// Move the common contents of the old table into the new table:

+	cCSLock Lock(m_CS);

+	for (int z = 0; z < NewHeight; z++)

+	{

+		int OldZ = z + a_MinChunkZ - m_BaseZ;

+		if ((OldZ < 0) || (OldZ >= m_Height))

+		{

+			continue;

+		}

+		for (int x = 0; x < NewWidth; x++)

+		{

+			int OldX = x + a_MinChunkX - m_BaseX;

+			if ((OldX < 0) || (OldX >= m_Width))

+			{

+				continue;

+			}

+			NewAvailable[x + NewWidth * z] = m_Available[OldX + m_Width * OldZ];

+			m_Available[OldX + m_Width * OldZ] = NULL;

+		}  // for x

+	}  // for z

+	

+	// All items that aren't common go into the pool:

+	for (int idx = 0, z = 0; z < m_Height; z++)

+	{

+		for (int x = 0; x < m_Width; ++x, ++idx)

+		{

+			if (m_Available[idx] != NULL)

+			{

+				m_Pool.push_back(m_Available[idx]);

+				m_Available[idx] = NULL;

+			}

+		}

+	}

+	

+	// Replace the cache table:

+	delete m_Available;

+	m_Available = NewAvailable;

+	m_Width = NewWidth;

+	m_Height = NewHeight;

+	m_BaseX = a_MinChunkX;

+	m_BaseZ = a_MinChunkZ;

+

+	// Remove all items outside the coords:

+	FilterOutItems(m_Queue, a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ);

+	

+	// Queue all items from inside the coords into m_Queue:

+	for (int z = 0; z < NewHeight; z++)

+	{

+		for (int x = 0; x < NewWidth; x++)

+		{

+			if (m_Available[x + m_Width * z] != NULL)

+			{

+				// Already calculated, skip

+				continue;

+			}

+			

+			if (m_Pool.empty())

+			{

+				m_Pool.push_back(new cItem(x + a_MinChunkX, z + a_MinChunkZ));

+			}

+			ASSERT(!m_Pool.empty());

+			m_Pool.back()->m_ChunkX = x + a_MinChunkX;

+			m_Pool.back()->m_ChunkZ = z + a_MinChunkZ;

+			m_Queue.push_back(m_Pool.back());

+			m_Pool.pop_back();

+			m_evtQueued.Set();

+		}  // for x

+	}  // for z

+}

+

+

+

+

+

+void cBiomeCache::SetSource(cBiomeSource * a_Source)

+{

+	// TODO: Stop all threads, so that they don't use the source anymore!

+	

+	delete m_Source;

+	m_Source = a_Source;

+	

+	// Invalidate cache contents:

+	cCSLock Lock(m_CS);

+	m_BaseX = -10000;

+	m_BaseZ = -10000;

+	m_Pool.splice(m_Pool.end(), m_Queue);

+}

+

+

+

+

+

+void cBiomeCache::FilterOutItems(cItems & a_Items, int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ)

+{

+	for (cItems::iterator itr = a_Items.begin(); itr != a_Items.end();)

+	{

+		if (

+			((*itr)->m_ChunkX < a_MinChunkX) ||

+			((*itr)->m_ChunkX > a_MaxChunkX) ||

+			((*itr)->m_ChunkX < a_MinChunkX) ||

+			((*itr)->m_ChunkX > a_MaxChunkX)

+		)

+		{

+			m_Pool.push_back(*itr);

+			itr = a_Items.erase(itr);

+		}

+		else

+		{

+			++itr;

+		}

+	}

+}

+

+

+

+

+

+void cBiomeCache::thrProcessQueueItem(void)

+{

+	cItem * Item = NULL;

+	{

+		cCSLock Lock(m_CS);

+		if (m_Queue.empty())

+		{

+			cCSUnlock Unlock(Lock);

+			m_evtQueued.Wait();

+		}

+		if (m_IsTerminatingThreads || m_Queue.empty())

+		{

+			// We've been woken up only to die / spurious wakeup

+			return;

+		}

+		Item = m_Queue.back();

+		m_Queue.pop_back();

+	}

+	

+	// Process the item:

+	Item->m_IsValid = (m_Source->GetBiome(Item->m_ChunkX, Item->m_ChunkZ, Item->m_Biomes) == baNow);

+	

+	// Store result:

+	cCSLock Lock(m_CS);

+	int x = Item->m_ChunkX - m_BaseX;

+	int z = Item->m_ChunkZ - m_BaseZ;

+	if ((x < 0) || (x >= m_Width) || (z < 0) || (z >= m_Height))

+	{

+		// The cache rectangle has changed under our fingers, drop this chunk

+		return;

+	}

+	m_Available[x + m_Width * z] = Item;

+}

+

+

+

+

+

+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+// cBiomeCache::cItem:

+

+cBiomeCache::cItem::cItem(int a_ChunkX, int a_ChunkZ) :

+	m_ChunkX(a_ChunkX),

+	m_ChunkZ(a_ChunkZ)

+{

+}

+

+

+

+

+

+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+// cBiomeCache::cThread:

+

+cBiomeCache::cThread::cThread(cBiomeCache & a_Parent) :

+	super("Biome cache thread"),

+	m_Parent(a_Parent)

+{

+}

+

+

+

+

+

+void cBiomeCache::cThread::Execute(void)

+{

+	while (!m_ShouldTerminate && !m_Parent.m_IsTerminatingThreads)

+	{

+		m_Parent.thrProcessQueueItem();

+	}

+}

+

+

+

+