1 files changed, 442 insertions, 25 deletions

diff --git a/source/LightingThread.cpp b/source/LightingThread.cpp
index 1bddb81bf..c2f876e32 100644
--- a/source/LightingThread.cpp
+++ b/source/LightingThread.cpp
@@ -5,6 +5,67 @@
 

 #include "Globals.h"

 #include "LightingThread.h"

+#include "cChunkMap.h"

+#include "cWorld.h"

+

+

+

+

+

+/// If more than this many chunks are in the queue, a warning is printed to the log

+#define WARN_ON_QUEUE_SIZE 800

+

+

+

+

+

+/// Chunk data callback that takes the chunk data and puts them into cLightingThread's m_BlockTypes[] / m_HeightMap[]:

+class cReader :

+	public cChunkDataCallback

+{

+	virtual void BlockTypes(const BLOCKTYPE * a_Type) override

+	{

+		// ROW is a block of 16 Blocks, one whole row is copied at a time (hopefully the compiler will optimize that)

+		// C++ doesn't permit copying arrays, but arrays as a part of a struct is ok :)

+		typedef struct {BLOCKTYPE m_Row[16]; } ROW;

+		ROW * InputRows = (ROW *)a_Type;

+		ROW * OutputRows = (ROW *)m_BlockTypes;

+		int InputIdx = 0;

+		int OutputIdx = m_ReadingChunkX + m_ReadingChunkZ * cChunkDef::Width * 3;

+		for (int y = 0; y < cChunkDef::Height; y++)

+		{

+			for (int z = 0; z < cChunkDef::Width; z++)

+			{

+				OutputRows[OutputIdx] = InputRows[InputIdx++];

+				OutputIdx += 3;

+			}  // for z

+			// Skip into the next y-level in the 3x3 chunk blob; each level has cChunkDef::Width * 9 rows

+			// We've already walked cChunkDef::Width * 3 in the "for z" cycle, that makes cChunkDef::Width * 6 rows left to skip

+			OutputIdx += cChunkDef::Width * 6;

+		}  // for y

+	}  // BlockTypes()

+	

+	

+	virtual void HeightMap(const cChunkDef::HeightMap * a_Heightmap) override

+	{

+		typedef struct {HEIGHTTYPE m_Row[16]; } ROW;

+		ROW * InputRows  = (ROW *)a_Heightmap;

+		ROW * OutputRows = (ROW *)m_HeightMap;

+		int InputIdx = 0;

+		int OutputIdx = m_ReadingChunkX + m_ReadingChunkZ * cChunkDef::Width * 3;

+		for (int z = 0; z < cChunkDef::Width; z++)

+		{

+			OutputRows[OutputIdx] = InputRows[InputIdx++];

+			OutputIdx += 3;

+		}  // for z

+	}

+	

+public:

+	int m_ReadingChunkX;  // 0, 1 or 2; x-offset of the chunk we're reading from the BlockTypes start

+	int m_ReadingChunkZ;  // 0, 1 or 2; z-offset of the chunk we're reading from the BlockTypes start

+	BLOCKTYPE * m_BlockTypes;  // 3x3 chunks of block types, organized as a single XZY blob of data (instead of 3x3 XZY blobs)

+	HEIGHTTYPE * m_HeightMap;  // 3x3 chunks of height map,  organized as a single XZY blob of data (instead of 3x3 XZY blobs)

+} ;

 

 

 

@@ -14,7 +75,8 @@
 // cLightingThread:

 

 cLightingThread::cLightingThread(void) :

-	super("cLightingThread")

+	super("cLightingThread"),

+	m_World(NULL)

 {

 }

 

@@ -31,17 +93,26 @@ cLightingThread::~cLightingThread()
 

 

 

+bool cLightingThread::Start(cWorld * a_World)

+{

+	ASSERT(m_World == NULL);  // Not started yet

+	m_World = a_World;

+	

+	return super::Start();

+}

+

+

+

+

+

 void cLightingThread::Stop(void)

 {

 	{

 		cCSLock Lock(m_CS);

-		for (cLightingBufferQueue::iterator itr = m_Queue.begin(); itr != m_Queue.end(); ++itr)

-		{

-			delete *itr;

-		}  // for itr - m_Queue[]

+		m_Queue.clear();

 	}

 	m_ShouldTerminate = true;

-	m_Event.Set();

+	m_evtItemAdded.Set();

 	

 	Wait();

 }

@@ -50,9 +121,89 @@ void cLightingThread::Stop(void)
 

 

 

-void cLightingThread::QueueLighting(cWorld * a_World, int a_MinX, int a_MaxX, int a_MinY, int a_MaxY, int a_MinZ, int a_MaxZ)

+void cLightingThread::QueueChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_CallbackAfter)

 {

-	// TODO

+	ASSERT(m_World != NULL);  // Did you call Start() properly?

+	

+	cChunkStay * ChunkStay = new cChunkStay(m_World);

+	ChunkStay->Add(a_ChunkX + 1, ZERO_CHUNK_Y, a_ChunkZ + 1);

+	ChunkStay->Add(a_ChunkX + 1, ZERO_CHUNK_Y, a_ChunkZ);

+	ChunkStay->Add(a_ChunkX + 1, ZERO_CHUNK_Y, a_ChunkZ - 1);

+	ChunkStay->Add(a_ChunkX,     ZERO_CHUNK_Y, a_ChunkZ + 1);

+	ChunkStay->Add(a_ChunkX,     ZERO_CHUNK_Y, a_ChunkZ);

+	ChunkStay->Add(a_ChunkX,     ZERO_CHUNK_Y, a_ChunkZ - 1);

+	ChunkStay->Add(a_ChunkX - 1, ZERO_CHUNK_Y, a_ChunkZ + 1);

+	ChunkStay->Add(a_ChunkX - 1, ZERO_CHUNK_Y, a_ChunkZ);

+	ChunkStay->Add(a_ChunkX - 1, ZERO_CHUNK_Y, a_ChunkZ - 1);

+	ChunkStay->Enable();

+	ChunkStay->Load();

+	cCSLock Lock(m_CS);

+	m_Queue.push_back(sItem(a_ChunkX, a_ChunkZ, ChunkStay, a_CallbackAfter));

+	if (m_Queue.size() > WARN_ON_QUEUE_SIZE)

+	{

+		LOGINFO("Lighting thread overloaded, %d items in queue", m_Queue.size());

+	}

+	m_evtItemAdded.Set();

+}

+

+

+

+

+

+void cLightingThread::WaitForQueueEmpty(void)

+{

+	cCSLock Lock(m_CS);

+	while (!m_ShouldTerminate && (!m_Queue.empty() || !m_PostponedQueue.empty()))

+	{

+		cCSUnlock Unlock(Lock);

+		m_evtQueueEmpty.Wait();

+	}

+}

+

+

+

+

+

+size_t cLightingThread::GetQueueLength(void)

+{

+	cCSLock Lock(m_CS);

+	return m_Queue.size() + m_PostponedQueue.size();

+}

+

+

+

+

+

+void cLightingThread::ChunkReady(int a_ChunkX, int a_ChunkZ)

+{

+	// Check all the items in the m_PostponedQueue, if the chunk is their neighbor, move the item to m_Queue

+	

+	bool NewlyAdded = false;

+	{

+		cCSLock Lock(m_CS);

+		for (sItems::iterator itr = m_PostponedQueue.begin(); itr != m_PostponedQueue.end(); )

+		{

+			if (

+				(itr->x - a_ChunkX >= -1) && (itr->x - a_ChunkX <= 1) &&

+				(itr->x - a_ChunkX >= -1) && (itr->x - a_ChunkX <= 1)

+			)

+			{

+				// It is a neighbor

+				m_Queue.push_back(*itr);

+				itr = m_PostponedQueue.erase(itr);

+				NewlyAdded = true;

+			}

+			else

+			{

+				++itr;

+			}

+		}  // for itr - m_PostponedQueue[]

+	}  // Lock(m_CS)

+	

+	if (NewlyAdded)

+	{

+		m_evtItemAdded.Set();  // Notify the thread it has some work to do

+	}

 }

 

 

@@ -61,52 +212,318 @@ void cLightingThread::QueueLighting(cWorld * a_World, int a_MinX, int a_MaxX, in
 

 void cLightingThread::Execute(void)

 {

-	// TODO

+	while (true)

+	{

+		{

+			cCSLock Lock(m_CS);

+			if (m_Queue.size() == 0)

+			{

+				cCSUnlock Unlock(Lock);

+				m_evtItemAdded.Wait();

+			}

+		}

+		

+		if (m_ShouldTerminate)

+		{

+			return;

+		}

+		

+		// Process one items from the queue:

+		sItem Item;

+		{

+			cCSLock Lock(m_CS);

+			if (m_Queue.empty())

+			{

+				continue;

+			}

+			Item = m_Queue.front();

+			m_Queue.pop_front();

+			if (m_Queue.empty())

+			{

+				m_evtQueueEmpty.Set();

+			}

+		}  // CSLock(m_CS)

+		

+		LightChunk(Item);

+	}

 }

 

 

 

 

 

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cLightingThread::cLightingBuffer:

 

-cLightingThread::cLightingBuffer::cLightingBuffer(int a_MinX, int a_MaxX, int a_MinY, int a_MaxY, int a_MinZ, int a_MaxZ) :

-	m_MinX(a_MinX), 

-	m_MaxX(a_MaxX),

-	m_MinY(a_MinY),

-	m_MaxY(a_MaxY),

-	m_MinZ(a_MinZ),

-	m_MaxZ(a_MaxZ)

+void cLightingThread::LightChunk(cLightingThread::sItem & a_Item)

 {

-	// TODO: initialize strides

+	cChunkDef::BlockNibbles BlockLight, SkyLight;

+	

+	if (!ReadChunks(a_Item.x, a_Item.z))

+	{

+		// Neighbors not available. Re-queue in the postponed queue

+		cCSLock Lock(m_CS);

+		m_PostponedQueue.push_back(a_Item);

+		return;

+	}

+	

+	/*

+	// DEBUG: torch somewhere:

+	m_BlockTypes[19 + 24 * cChunkDef::Width * 3 + (m_HeightMap[24 + 24 * cChunkDef::Width * 3] / 2) * BlocksPerYLayer] = E_BLOCK_TORCH;

+	// m_HeightMap[24 + 24 * cChunkDef::Width * 3]++;

+	*/

+	

+	PrepareBlockLight();

+	CalcLight(m_BlockLight);

+	

+	PrepareSkyLight();

+	CalcLight(m_SkyLight);

+	

+	CompressLight(m_BlockLight, BlockLight);

+	CompressLight(m_SkyLight, SkyLight);

+	

+	/*

+	// DEBUG:

+	{

+		cFile f("chunk_BlockTypes.dat", cFile::fmWrite);

+		if (f.IsOpen())

+		{

+			f.Write(m_BlockTypes, sizeof(m_BlockTypes));

+		}

+	}

+	

+	// DEBUG:

+	{

+		cFile f("Chunk_SkyLight.dat", cFile::fmWrite);

+		if (f.IsOpen())

+		{

+			f.Write(m_SkyLight, sizeof(m_SkyLight));

+		}

+	}

+	

+	// DEBUG:

+	{

+		cFile f("Chunk_BlockLight.dat", cFile::fmWrite);

+		if (f.IsOpen())

+		{

+			f.Write(m_BlockLight, sizeof(m_BlockLight));

+		}

+	}

+	*/

+	

+	m_World->ChunkLighted(a_Item.x, a_Item.z, BlockLight, SkyLight);

+

+	if (a_Item.m_Callback != NULL)

+	{

+		a_Item.m_Callback->Call(a_Item.x, a_Item.z);

+	}

+	delete a_Item.m_ChunkStay;

+}

+

+

+

+

+

+bool cLightingThread::ReadChunks(int a_ChunkX, int a_ChunkZ)

+{

+	cReader Reader;

+	Reader.m_BlockTypes = m_BlockTypes;

+	Reader.m_HeightMap  = m_HeightMap;

+	

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

+	{

+		Reader.m_ReadingChunkZ = z;

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

+		{

+			Reader.m_ReadingChunkX = x;

+			if (!m_World->GetChunkData(a_ChunkX + x - 1, ZERO_CHUNK_Y, a_ChunkZ + z - 1, Reader))

+			{

+				return false;

+			}

+		}  // for z

+	}  // for x

+	

+	memset(m_BlockLight, 0, sizeof(m_BlockLight));

+	memset(m_SkyLight,   0, sizeof(m_SkyLight));

+	return true;

+}

+

+

+

+

+

+void cLightingThread::PrepareSkyLight(void)

+{

+	// Clear seeds:

+	memset(m_IsSeed1, 0, sizeof(m_IsSeed1));

+	m_NumSeeds = 0;

+	

+	// Walk every column that has all XZ neighbors

+	for (int z = 1; z < cChunkDef::Width * 3 - 1; z++)

+	{

+		int BaseZ = z * cChunkDef::Width * 3;

+		for (int x = 1; x < cChunkDef::Width * 3 - 1; x++)

+		{

+			int idx = BaseZ + x;

+			int Current   = m_HeightMap[idx] + 1;

+			int Neighbor1 = m_HeightMap[idx + 1] + 1;  // X + 1

+			int Neighbor2 = m_HeightMap[idx - 1] + 1;  // X - 1

+			int Neighbor3 = m_HeightMap[idx + cChunkDef::Width * 3] + 1;  // Z + 1

+			int Neighbor4 = m_HeightMap[idx - cChunkDef::Width * 3] + 1;  // Z - 1

+			int MaxNeighbor = MAX(MAX(Neighbor1, Neighbor2), MAX(Neighbor3, Neighbor4));  // Maximum of the four neighbors

+			

+			// TODO: The following cycle can be transofrmed into two separate cycles with no condition inside them, one lighting and the other seeding

+			for (int y = Current, Index = idx + y * BlocksPerYLayer; y < cChunkDef::Height; y++, Index += BlocksPerYLayer)

+			{

+				// If all the XZ neighbors are lower than y, abort for the current column (but light up the rest of it):

+				if (y >= MaxNeighbor)

+				{

+					for (int y2 = y; y2 < cChunkDef::Height; y2++, Index += BlocksPerYLayer)

+					{

+						m_SkyLight[Index] = 15;

+					}  // for y2

+					break;  // for y

+				}

+

+				// Add current block as a seed:

+				m_IsSeed1[Index] = true;

+				m_SeedIdx1[m_NumSeeds++] = Index;

+

+				// Light it up to full skylight:

+				m_SkyLight[Index] = 15;

+			}

+		}

+	}

+}

+

+

+

+

+

+void cLightingThread::PrepareBlockLight(void)

+{

+	// Clear seeds:

+	memset(m_IsSeed1, 0, sizeof(m_IsSeed1));

+	m_NumSeeds = 0;

+

+	// Walk every column that has all XZ neighbors, make a seed for each light-emitting block:

+	for (int z = 1; z < cChunkDef::Width * 3 - 1; z++)

+	{

+		int BaseZ = z * cChunkDef::Width * 3;

+		for (int x = 1; x < cChunkDef::Width * 3 - 1; x++)

+		{

+			int idx = BaseZ + x;

+			for (int y = m_HeightMap[idx], Index = idx + y * BlocksPerYLayer; y >= 0; y--, Index -= BlocksPerYLayer)

+			{

+				if (g_BlockLightValue[m_BlockTypes[Index]] == 0)

+				{

+					continue;

+				}

+				

+				// Add current block as a seed:

+				m_IsSeed1[Index] = true;

+				m_SeedIdx1[m_NumSeeds++] = Index;

+

+				// Light it up:

+				m_BlockLight[Index] = g_BlockLightValue[m_BlockTypes[Index]];

+			}

+		}

+	}

 }

 

 

 

 

 

-void cLightingThread::cLightingBuffer::GetFromWorld(cWorld * a_World)

+void cLightingThread::CalcLight(NIBBLETYPE * a_Light)

 {

-	// TODO: Set m_BlockData, m_SkyLight and m_BlockLight from the world's chunks

+	int NumSeeds2 = 0;

+	while (m_NumSeeds > 0)

+	{

+		// Buffer 1 -> buffer 2

+		memset(m_IsSeed2, 0, sizeof(m_IsSeed2));

+		NumSeeds2 = 0;

+		CalcLightStep(a_Light, m_NumSeeds, m_IsSeed1, m_SeedIdx1, NumSeeds2, m_IsSeed2, m_SeedIdx2);

+		if (NumSeeds2 == 0)

+		{

+			return;

+		}

+		

+		// Buffer 2 -> buffer 1

+		memset(m_IsSeed1, 0, sizeof(m_IsSeed1));

+		m_NumSeeds = 0;

+		CalcLightStep(a_Light, NumSeeds2, m_IsSeed2, m_SeedIdx2, m_NumSeeds, m_IsSeed1, m_SeedIdx1);

+	}

 }

 

 

 

 

 

-void cLightingThread::cLightingBuffer::SetToWorld  (cWorld * a_World)

+void cLightingThread::CalcLightStep(

+	NIBBLETYPE * a_Light, 

+	int a_NumSeedsIn,    unsigned char * a_IsSeedIn,  unsigned int * a_SeedIdxIn,

+	int & a_NumSeedsOut, unsigned char * a_IsSeedOut, unsigned int * a_SeedIdxOut

+)

 {

-	// TODO: Set world's chunks from m_BlockData, m_SkyLight and m_BlockLight

+	int NumSeedsOut = 0;

+	for (int i = 0; i < a_NumSeedsIn; i++)

+	{

+		int SeedIdx = a_SeedIdxIn[i];

+		int SeedX = SeedIdx % (cChunkDef::Width * 3);

+		int SeedZ = (SeedIdx / (cChunkDef::Width * 3)) % (cChunkDef::Width * 3);

+		int SeedY = SeedIdx / BlocksPerYLayer;

+		

+		// Propagate seed:

+		if (SeedX < cChunkDef::Width * 3)

+		{

+			PropagateLight(a_Light, SeedIdx, SeedIdx + 1, NumSeedsOut, a_IsSeedOut, a_SeedIdxOut);

+		}

+		if (SeedX > 0)

+		{

+			PropagateLight(a_Light, SeedIdx, SeedIdx - 1, NumSeedsOut, a_IsSeedOut, a_SeedIdxOut);

+		}

+		if (SeedZ < cChunkDef::Width * 3)

+		{

+			PropagateLight(a_Light, SeedIdx, SeedIdx + cChunkDef::Width * 3, NumSeedsOut, a_IsSeedOut, a_SeedIdxOut);

+		}

+		if (SeedZ > 0)

+		{

+			PropagateLight(a_Light, SeedIdx, SeedIdx - cChunkDef::Width * 3, NumSeedsOut, a_IsSeedOut, a_SeedIdxOut);

+		}

+		if (SeedY < cChunkDef::Height)

+		{

+			PropagateLight(a_Light, SeedIdx, SeedIdx + cChunkDef::Width * cChunkDef::Width * 3 * 3, NumSeedsOut, a_IsSeedOut, a_SeedIdxOut);

+		}

+		if (SeedY > 0)

+		{

+			PropagateLight(a_Light, SeedIdx, SeedIdx - cChunkDef::Width * cChunkDef::Width * 3 * 3, NumSeedsOut, a_IsSeedOut, a_SeedIdxOut);

+		}

+	}  // for i - a_SeedIdxIn[]

+	a_NumSeedsOut = NumSeedsOut;

 }

 

 

 

 

 

-void cLightingThread::cLightingBuffer::Process(void)

+void cLightingThread::CompressLight(NIBBLETYPE * a_LightArray, NIBBLETYPE * a_ChunkLight)

 {

-	// TODO: Does the actual lighting on this buffer

+	int InIdx = cChunkDef::Width * 49;  // Index to the first nibble of the middle chunk in the a_LightArray

+	int OutIdx = 0;

+	for (int y = 0; y < cChunkDef::Height; y++)

+	{

+		for (int z = 0; z < cChunkDef::Width; z++)

+		{

+			for (int x = 0; x < cChunkDef::Width; x += 2)

+			{

+				a_ChunkLight[OutIdx++] = (a_LightArray[InIdx + 1] << 4) | a_LightArray[InIdx];

+				InIdx += 2;

+			}

+			InIdx += cChunkDef::Width * 2;

+		}

+		// Skip into the next y-level in the 3x3 chunk blob; each level has cChunkDef::Width * 9 rows

+		// We've already walked cChunkDef::Width * 3 in the "for z" cycle, that makes cChunkDef::Width * 6 rows left to skip

+		InIdx += cChunkDef::Width * cChunkDef::Width * 6;

+	}

 }