From 024027db89ca833406147b79b7be74fc92906bbe Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Wed, 21 May 2014 19:58:48 +0100
Subject: Renamed cChunkBuffer to cChunkData

---
 src/ChunkData.h | 279 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 279 insertions(+)
 create mode 100644 src/ChunkData.h

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
new file mode 100644
index 000000000..809f3cdf2
--- /dev/null
+++ b/src/ChunkData.h
@@ -0,0 +1,279 @@
+
+#pragma once
+
+
+#include <cstring>
+
+
+#include "ChunkDef.h"
+
+
+#define CHUNK_SECTION_HEIGHT 16
+#define CHUNK_SECTION_NUM (256 / CHUNK_SECTION_HEIGHT)
+
+#if __cplusplus < 201103L
+// auto_ptr style interface for memory management
+#else
+// unique_ptr style interface for memory management
+#endif
+
+class cChunkData
+{
+public:
+
+	cChunkData()
+	#if __cplusplus < 201103L
+	// auto_ptr style interface for memory management
+	: IsOwner(true)
+	#endif
+	{
+		memset(m_Sections, 0, sizeof(m_Sections));
+	}
+	~cChunkData()
+	{
+		#if __cplusplus < 201103L
+		// auto_ptr style interface for memory management
+		if(!IsOwner) return;
+		#endif
+		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+		{
+			if(m_Sections[i]) Free(m_Sections[i]);;
+		}
+	}
+	
+	#if __cplusplus < 201103L
+	// auto_ptr style interface for memory management
+	cChunkData(const cChunkData& other) :
+	IsOwner(true)
+	{
+		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+		{
+			m_Sections[i] = other.m_Sections[i];
+		}
+		other.IsOwner = false;
+	}
+
+	cChunkData& operator=(const cChunkData& other)
+	{
+		if(&other != this)
+		{
+			if(IsOwner)
+			{
+				for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+				{
+					if(m_Sections[i]) Free(m_Sections[i]);;
+				}
+			}
+			IsOwner = true;
+			for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+			{
+				m_Sections[i] = other.m_Sections[i];
+			}
+			other.IsOwner = false;
+		}
+		return *this;
+		
+	}
+	#else
+	// unique_ptr style interface for memory management
+	cChunkData(cChunkData&& other)
+	{
+		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+		{
+			m_Sections[i] = other.m_Sections[i];
+			other.m_Sections[i] = 0;
+		}
+	}
+	
+	cChunkData& operator=(cChunkData&& other)
+	{
+		if(&other != this)
+		{
+			for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+			{
+				if(m_Sections[i]) Free(m_Sections[i]);;
+				m_Sections[i] = other.m_Sections[i];
+				other.m_Sections[i] = 0;
+			}
+		}
+		return *this;
+	}
+	#endif
+
+	BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const
+	{
+		ASSERT((a_X >= 0) && (a_X < cChunkDef::Width));
+		ASSERT((a_Y >= 0) && (a_Y < cChunkDef::Height));
+		ASSERT((a_Z >= 0) && (a_Z < cChunkDef::Width));
+		int Section = a_Y / CHUNK_SECTION_HEIGHT;
+		if(m_Sections[Section])
+		{
+			int Index = cChunkDef::MakeIndexNoCheck(a_X, a_Y - (Section * CHUNK_SECTION_HEIGHT), a_Z);
+			return m_Sections[Section]->m_BlockTypes[Index];
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	
+	void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block)
+	{
+		if (
+			(a_RelX >= cChunkDef::Width)  || (a_RelX < 0) ||
+			(a_RelY >= cChunkDef::Height) || (a_RelY < 0) ||
+			(a_RelZ >= cChunkDef::Width)  || (a_RelZ < 0)
+		)
+		{
+			ASSERT(!"cChunkData::SetMeta(): index out of range!");
+			return;
+		}
+
+		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
+		if(!m_Sections[Section])
+		{
+			if(a_Block == 0x00)
+			{
+				return;
+			}
+			m_Sections[Section] = Allocate();
+			if(!m_Sections[Section])
+			{
+				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
+				return;
+			}
+			ZeroSection(m_Sections[Section]);
+		}
+		int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
+		m_Sections[Section]->m_BlockTypes[Index] = a_Block;
+	}
+
+	NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
+	{
+		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
+		{
+			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
+			if(m_Sections[Section])
+			{
+				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
+				return (m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+		ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!");
+		return 0;
+	}
+	
+	void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble)
+	{
+		if (
+			(a_RelX >= cChunkDef::Width)  || (a_RelX < 0) ||
+			(a_RelY >= cChunkDef::Height) || (a_RelY < 0) ||
+			(a_RelZ >= cChunkDef::Width)  || (a_RelZ < 0)
+		)
+		{
+			ASSERT(!"cChunkData::SetMeta(): index out of range!");
+			return;
+		}
+
+		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
+		if(!m_Sections[Section])
+		{
+			if((a_Nibble & 0xf) == 0x00)
+			{
+				return;
+			}
+			m_Sections[Section] = Allocate();
+			if(!m_Sections[Section])
+			{
+				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
+				return;
+			}
+			ZeroSection(m_Sections[Section]);
+		}
+		int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
+		m_Sections[Section]->m_BlockMeta[Index / 2] = static_cast<NIBBLETYPE>(
+			(m_Sections[Section]->m_BlockMeta[Index / 2] & (0xf0 >> ((Index & 1) * 4))) |  // The untouched nibble
+			((a_Nibble & 0x0f) << ((Index & 1) * 4))  // The nibble being set
+		);
+	}
+	
+	NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const
+	{
+		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
+		{
+			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
+			if(m_Sections[Section])
+			{
+				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
+				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+		ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!");
+		return 0;
+	}
+	
+	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const
+	{
+		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
+		{
+			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
+			if(m_Sections[Section])
+			{
+				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
+				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
+			}
+			else
+			{
+				return 0xF;
+			}
+		}
+		ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!");
+		return 0;
+	}
+	
+	cChunkData Copy() const;
+	void CopyBlocks   (BLOCKTYPE * a_dest, size_t a_Idx = 0, size_t length = cChunkDef::NumBlocks)  const;
+	void CopyMeta     (NIBBLETYPE * a_dest) const;
+	void CopyLight    (NIBBLETYPE * a_dest) const;
+	void CopySkyLight (NIBBLETYPE * a_dest) const;
+	
+	void SetBlocks    (const BLOCKTYPE * a_src);
+	void SetMeta      (const NIBBLETYPE * a_src);
+	void SetLight     (const NIBBLETYPE * a_src);
+	void SetSkyLight  (const NIBBLETYPE * a_src);
+	
+private:
+
+	#if __cplusplus < 201103L
+	// auto_ptr style interface for memory management
+	mutable bool IsOwner;
+	#endif
+	
+	struct sChunkSection {
+		BLOCKTYPE  m_BlockTypes   [CHUNK_SECTION_HEIGHT * 16 * 16]    ;
+		NIBBLETYPE m_BlockMeta    [CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
+		NIBBLETYPE m_BlockLight   [CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
+		NIBBLETYPE m_BlockSkyLight[CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
+	};
+	
+	sChunkSection *m_Sections[CHUNK_SECTION_NUM];
+	
+	sChunkSection * Allocate() const;
+	void Free(sChunkSection * ptr) const;
+	
+	void ZeroSection(sChunkSection * ptr) const;
+};
+
+
+
+
+
+
-- 
cgit v1.2.3


From 5929ffbc40d24f4e69cf12c8495d194407547c9c Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Wed, 21 May 2014 20:08:34 +0100
Subject: Fixed stylistic issues

---
 src/ChunkData.h | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 809f3cdf2..24a437629 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -37,7 +37,7 @@ public:
 		#endif
 		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
 		{
-			if(m_Sections[i]) Free(m_Sections[i]);;
+			if(m_Sections[i] == NULL) Free(m_Sections[i]);;
 		}
 	}
 	
@@ -91,7 +91,7 @@ public:
 		{
 			for (int i = 0; i < CHUNK_SECTION_NUM; i++)
 			{
-				if(m_Sections[i]) Free(m_Sections[i]);;
+				Free(m_Sections[i]);;
 				m_Sections[i] = other.m_Sections[i];
 				other.m_Sections[i] = 0;
 			}
@@ -106,7 +106,7 @@ public:
 		ASSERT((a_Y >= 0) && (a_Y < cChunkDef::Height));
 		ASSERT((a_Z >= 0) && (a_Z < cChunkDef::Width));
 		int Section = a_Y / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section])
+		if(m_Sections[Section] == NULL)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(a_X, a_Y - (Section * CHUNK_SECTION_HEIGHT), a_Z);
 			return m_Sections[Section]->m_BlockTypes[Index];
@@ -130,14 +130,14 @@ public:
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if(!m_Sections[Section])
+		if(m_Sections[Section] != NULL)
 		{
 			if(a_Block == 0x00)
 			{
 				return;
 			}
 			m_Sections[Section] = Allocate();
-			if(!m_Sections[Section])
+			if(m_Sections[Section] != NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 				return;
@@ -153,7 +153,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section])
+			if(m_Sections[Section] == NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -180,14 +180,14 @@ public:
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if(!m_Sections[Section])
+		if(m_Sections[Section] != NULL)
 		{
 			if((a_Nibble & 0xf) == 0x00)
 			{
 				return;
 			}
 			m_Sections[Section] = Allocate();
-			if(!m_Sections[Section])
+			if(m_Sections[Section] != NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 				return;
@@ -206,7 +206,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section])
+			if(m_Sections[Section] == NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -225,7 +225,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section])
+			if(m_Sections[Section] == NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
-- 
cgit v1.2.3


From bd880603a560160d247d79a2fdeb3fbab26994f0 Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Wed, 21 May 2014 20:18:09 +0100
Subject: Changed cChunkData::SetMeta to return a bool indicating whether the
 value changed

---
 src/ChunkData.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 24a437629..73b1e8c6a 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -167,7 +167,7 @@ public:
 		return 0;
 	}
 	
-	void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble)
+	bool SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble)
 	{
 		if (
 			(a_RelX >= cChunkDef::Width)  || (a_RelX < 0) ||
@@ -176,7 +176,7 @@ public:
 		)
 		{
 			ASSERT(!"cChunkData::SetMeta(): index out of range!");
-			return;
+			return false;
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
@@ -184,21 +184,23 @@ public:
 		{
 			if((a_Nibble & 0xf) == 0x00)
 			{
-				return;
+				return false;
 			}
 			m_Sections[Section] = Allocate();
 			if(m_Sections[Section] != NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
-				return;
+				return false;
 			}
 			ZeroSection(m_Sections[Section]);
 		}
 		int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
+		NIBBLETYPE oldval = m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4) & 0xf;
 		m_Sections[Section]->m_BlockMeta[Index / 2] = static_cast<NIBBLETYPE>(
 			(m_Sections[Section]->m_BlockMeta[Index / 2] & (0xf0 >> ((Index & 1) * 4))) |  // The untouched nibble
 			((a_Nibble & 0x0f) << ((Index & 1) * 4))  // The nibble being set
 		);
+		return oldval == a_Nibble;
 	}
 	
 	NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const
-- 
cgit v1.2.3


From 88c61a2e96af9c7d1b173c0b580cef2c348850d7 Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Wed, 21 May 2014 21:18:14 +0100
Subject: Fixed reversed comparisons to null

---
 src/ChunkData.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 73b1e8c6a..51244225b 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -106,7 +106,7 @@ public:
 		ASSERT((a_Y >= 0) && (a_Y < cChunkDef::Height));
 		ASSERT((a_Z >= 0) && (a_Z < cChunkDef::Width));
 		int Section = a_Y / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section] == NULL)
+		if(m_Sections[Section] != NULL)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(a_X, a_Y - (Section * CHUNK_SECTION_HEIGHT), a_Z);
 			return m_Sections[Section]->m_BlockTypes[Index];
@@ -130,14 +130,14 @@ public:
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section] != NULL)
+		if(m_Sections[Section] == NULL)
 		{
 			if(a_Block == 0x00)
 			{
 				return;
 			}
 			m_Sections[Section] = Allocate();
-			if(m_Sections[Section] != NULL)
+			if(m_Sections[Section] == NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 				return;
@@ -153,7 +153,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section] == NULL)
+			if(m_Sections[Section] != NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -180,14 +180,14 @@ public:
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section] != NULL)
+		if(m_Sections[Section] == NULL)
 		{
 			if((a_Nibble & 0xf) == 0x00)
 			{
 				return false;
 			}
 			m_Sections[Section] = Allocate();
-			if(m_Sections[Section] != NULL)
+			if(m_Sections[Section] == NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 				return false;
@@ -208,7 +208,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section] == NULL)
+			if(m_Sections[Section] != NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -227,7 +227,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section] == NULL)
+			if(m_Sections[Section] != NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
-- 
cgit v1.2.3


From 4b23472097fa2daee464b6c5d73da56a0706731c Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Wed, 21 May 2014 21:46:20 +0100
Subject: Fixed if spaces

---
 src/ChunkData.h | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 51244225b..9c852ee24 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -33,11 +33,11 @@ public:
 	{
 		#if __cplusplus < 201103L
 		// auto_ptr style interface for memory management
-		if(!IsOwner) return;
+		if (!IsOwner) return;
 		#endif
 		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
 		{
-			if(m_Sections[i] == NULL) Free(m_Sections[i]);;
+			if (m_Sections[i] == NULL) Free(m_Sections[i]);;
 		}
 	}
 	
@@ -55,13 +55,13 @@ public:
 
 	cChunkData& operator=(const cChunkData& other)
 	{
-		if(&other != this)
+		if (&other != this)
 		{
-			if(IsOwner)
+			if (IsOwner)
 			{
 				for (int i = 0; i < CHUNK_SECTION_NUM; i++)
 				{
-					if(m_Sections[i]) Free(m_Sections[i]);;
+					if (m_Sections[i]) Free(m_Sections[i]);;
 				}
 			}
 			IsOwner = true;
@@ -87,7 +87,7 @@ public:
 	
 	cChunkData& operator=(cChunkData&& other)
 	{
-		if(&other != this)
+		if (&other != this)
 		{
 			for (int i = 0; i < CHUNK_SECTION_NUM; i++)
 			{
@@ -106,7 +106,7 @@ public:
 		ASSERT((a_Y >= 0) && (a_Y < cChunkDef::Height));
 		ASSERT((a_Z >= 0) && (a_Z < cChunkDef::Width));
 		int Section = a_Y / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section] != NULL)
+		if (m_Sections[Section] != NULL)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(a_X, a_Y - (Section * CHUNK_SECTION_HEIGHT), a_Z);
 			return m_Sections[Section]->m_BlockTypes[Index];
@@ -130,14 +130,14 @@ public:
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section] == NULL)
+		if (m_Sections[Section] == NULL)
 		{
-			if(a_Block == 0x00)
+			if (a_Block == 0x00)
 			{
 				return;
 			}
 			m_Sections[Section] = Allocate();
-			if(m_Sections[Section] == NULL)
+			if (m_Sections[Section] == NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 				return;
@@ -153,7 +153,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section] != NULL)
+			if (m_Sections[Section] != NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -180,14 +180,14 @@ public:
 		}
 
 		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if(m_Sections[Section] == NULL)
+		if (m_Sections[Section] == NULL)
 		{
-			if((a_Nibble & 0xf) == 0x00)
+			if ((a_Nibble & 0xf) == 0x00)
 			{
 				return false;
 			}
 			m_Sections[Section] = Allocate();
-			if(m_Sections[Section] == NULL)
+			if (m_Sections[Section] == NULL)
 			{
 				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
 				return false;
@@ -208,7 +208,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section] != NULL)
+			if (m_Sections[Section] != NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
@@ -227,7 +227,7 @@ public:
 		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if(m_Sections[Section] != NULL)
+			if (m_Sections[Section] != NULL)
 			{
 				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
 				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
-- 
cgit v1.2.3


From 8f964886e0ccbf51dac07227f0ac4c739b47d3a5 Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Sat, 24 May 2014 13:33:40 +0100
Subject: Implemented style changes

---
 src/ChunkData.h | 108 ++++++++++++++++++++++++++++++--------------------------
 1 file changed, 58 insertions(+), 50 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 9c852ee24..5a149f95f 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -8,8 +8,7 @@
 #include "ChunkDef.h"
 
 
-#define CHUNK_SECTION_HEIGHT 16
-#define CHUNK_SECTION_NUM (256 / CHUNK_SECTION_HEIGHT)
+
 
 #if __cplusplus < 201103L
 // auto_ptr style interface for memory management
@@ -23,8 +22,8 @@ public:
 
 	cChunkData()
 	#if __cplusplus < 201103L
-	// auto_ptr style interface for memory management
-	: IsOwner(true)
+		// auto_ptr style interface for memory management
+		: IsOwner(true)
 	#endif
 	{
 		memset(m_Sections, 0, sizeof(m_Sections));
@@ -32,72 +31,75 @@ public:
 	~cChunkData()
 	{
 		#if __cplusplus < 201103L
-		// auto_ptr style interface for memory management
-		if (!IsOwner) return;
+			// auto_ptr style interface for memory management
+			if (!IsOwner)
+			{
+				return;
+			}
 		#endif
-		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+		for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
 		{
 			if (m_Sections[i] == NULL) Free(m_Sections[i]);;
 		}
 	}
 	
 	#if __cplusplus < 201103L
-	// auto_ptr style interface for memory management
-	cChunkData(const cChunkData& other) :
-	IsOwner(true)
-	{
-		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+		// auto_ptr style interface for memory management
+		cChunkData(const cChunkData& other) :
+		IsOwner(true)
 		{
-			m_Sections[i] = other.m_Sections[i];
+			for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
+			{
+				m_Sections[i] = other.m_Sections[i];
+			}
+			other.IsOwner = false;
 		}
-		other.IsOwner = false;
-	}
 
-	cChunkData& operator=(const cChunkData& other)
-	{
-		if (&other != this)
+		cChunkData& operator=(const cChunkData& other)
 		{
-			if (IsOwner)
+			if (&other != this)
 			{
-				for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+				if (IsOwner)
 				{
-					if (m_Sections[i]) Free(m_Sections[i]);;
+					for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
+					{
+						if (m_Sections[i]) Free(m_Sections[i]);;
+					}
 				}
+				IsOwner = true;
+				for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
+				{
+					m_Sections[i] = other.m_Sections[i];
+				}
+				other.IsOwner = false;
 			}
-			IsOwner = true;
-			for (int i = 0; i < CHUNK_SECTION_NUM; i++)
-			{
-				m_Sections[i] = other.m_Sections[i];
-			}
-			other.IsOwner = false;
-		}
-		return *this;
+			return *this;
 		
-	}
+		}
 	#else
-	// unique_ptr style interface for memory management
-	cChunkData(cChunkData&& other)
-	{
-		for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+		// unique_ptr style interface for memory management
+		cChunkData(cChunkData&& other)
 		{
-			m_Sections[i] = other.m_Sections[i];
-			other.m_Sections[i] = 0;
+			for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
+			{
+				m_Sections[i] = other.m_Sections[i];
+				other.m_Sections[i] = NULL;
+			}
 		}
-	}
 	
-	cChunkData& operator=(cChunkData&& other)
-	{
-		if (&other != this)
+		cChunkData& operator=(cChunkData&& other)
 		{
-			for (int i = 0; i < CHUNK_SECTION_NUM; i++)
+			if (&other != this)
 			{
-				Free(m_Sections[i]);;
-				m_Sections[i] = other.m_Sections[i];
-				other.m_Sections[i] = 0;
+				for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
+				{
+					Free(m_Sections[i]);;
+					m_Sections[i] = other.m_Sections[i];
+					other.m_Sections[i] = NULL;
+				}
 			}
+			return *this;
 		}
-		return *this;
-	}
 	#endif
 
 	BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const
@@ -150,7 +152,10 @@ public:
 
 	NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
 	{
-		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
+		if (
+			(a_RelX < cChunkDef::Width) && (a_RelX > -1) &&
+			(a_RelY < cChunkDef::Height) && (a_RelY > -1) &&
+			(a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
 		{
 			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
 			if (m_Sections[Section] != NULL)
@@ -244,16 +249,19 @@ public:
 	cChunkData Copy() const;
 	void CopyBlocks   (BLOCKTYPE * a_dest, size_t a_Idx = 0, size_t length = cChunkDef::NumBlocks)  const;
 	void CopyMeta     (NIBBLETYPE * a_dest) const;
-	void CopyLight    (NIBBLETYPE * a_dest) const;
+	void CopyBlockLight    (NIBBLETYPE * a_dest) const;
 	void CopySkyLight (NIBBLETYPE * a_dest) const;
 	
 	void SetBlocks    (const BLOCKTYPE * a_src);
 	void SetMeta      (const NIBBLETYPE * a_src);
-	void SetLight     (const NIBBLETYPE * a_src);
+	void SetBlockLight     (const NIBBLETYPE * a_src);
 	void SetSkyLight  (const NIBBLETYPE * a_src);
 	
 private:
 
+	static const size_t CHUNK_SECTION_HEIGHT = 16;
+	static const size_t CHUNK_SECTION_COUNT = (256 / CHUNK_SECTION_HEIGHT);
+
 	#if __cplusplus < 201103L
 	// auto_ptr style interface for memory management
 	mutable bool IsOwner;
@@ -266,7 +274,7 @@ private:
 		NIBBLETYPE m_BlockSkyLight[CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
 	};
 	
-	sChunkSection *m_Sections[CHUNK_SECTION_NUM];
+	sChunkSection *m_Sections[CHUNK_SECTION_COUNT];
 	
 	sChunkSection * Allocate() const;
 	void Free(sChunkSection * ptr) const;
-- 
cgit v1.2.3


From 7fac63cffbe226ab025435a1e01e5f2430e52806 Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Sat, 24 May 2014 13:37:25 +0100
Subject: Moved accessors to cpp file

---
 src/ChunkData.h | 227 +++-----------------------------------------------------
 1 file changed, 12 insertions(+), 215 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 5a149f95f..16fcc4d37 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -20,231 +20,28 @@ class cChunkData
 {
 public:
 
-	cChunkData()
-	#if __cplusplus < 201103L
-		// auto_ptr style interface for memory management
-		: IsOwner(true)
-	#endif
-	{
-		memset(m_Sections, 0, sizeof(m_Sections));
-	}
-	~cChunkData()
-	{
-		#if __cplusplus < 201103L
-			// auto_ptr style interface for memory management
-			if (!IsOwner)
-			{
-				return;
-			}
-		#endif
-		for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
-		{
-			if (m_Sections[i] == NULL) Free(m_Sections[i]);;
-		}
-	}
+	cChunkData();
+	~cChunkData();
 	
 	#if __cplusplus < 201103L
 		// auto_ptr style interface for memory management
-		cChunkData(const cChunkData& other) :
-		IsOwner(true)
-		{
-			for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
-			{
-				m_Sections[i] = other.m_Sections[i];
-			}
-			other.IsOwner = false;
-		}
-
-		cChunkData& operator=(const cChunkData& other)
-		{
-			if (&other != this)
-			{
-				if (IsOwner)
-				{
-					for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
-					{
-						if (m_Sections[i]) Free(m_Sections[i]);;
-					}
-				}
-				IsOwner = true;
-				for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
-				{
-					m_Sections[i] = other.m_Sections[i];
-				}
-				other.IsOwner = false;
-			}
-			return *this;
-		
-		}
+		cChunkData(const cChunkData& other);
+		cChunkData& operator=(const cChunkData& other);
 	#else
 		// unique_ptr style interface for memory management
-		cChunkData(cChunkData&& other)
-		{
-			for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
-			{
-				m_Sections[i] = other.m_Sections[i];
-				other.m_Sections[i] = NULL;
-			}
-		}
-	
-		cChunkData& operator=(cChunkData&& other)
-		{
-			if (&other != this)
-			{
-				for (size_t i = 0; i < CHUNK_SECTION_COUNT; i++)
-				{
-					Free(m_Sections[i]);;
-					m_Sections[i] = other.m_Sections[i];
-					other.m_Sections[i] = NULL;
-				}
-			}
-			return *this;
-		}
+		cChunkData(cChunkData&& other);
+		cChunkData& operator=(cChunkData&& other);
 	#endif
 
-	BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const
-	{
-		ASSERT((a_X >= 0) && (a_X < cChunkDef::Width));
-		ASSERT((a_Y >= 0) && (a_Y < cChunkDef::Height));
-		ASSERT((a_Z >= 0) && (a_Z < cChunkDef::Width));
-		int Section = a_Y / CHUNK_SECTION_HEIGHT;
-		if (m_Sections[Section] != NULL)
-		{
-			int Index = cChunkDef::MakeIndexNoCheck(a_X, a_Y - (Section * CHUNK_SECTION_HEIGHT), a_Z);
-			return m_Sections[Section]->m_BlockTypes[Index];
-		}
-		else
-		{
-			return 0;
-		}
-	}
-	
-	void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block)
-	{
-		if (
-			(a_RelX >= cChunkDef::Width)  || (a_RelX < 0) ||
-			(a_RelY >= cChunkDef::Height) || (a_RelY < 0) ||
-			(a_RelZ >= cChunkDef::Width)  || (a_RelZ < 0)
-		)
-		{
-			ASSERT(!"cChunkData::SetMeta(): index out of range!");
-			return;
-		}
-
-		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if (m_Sections[Section] == NULL)
-		{
-			if (a_Block == 0x00)
-			{
-				return;
-			}
-			m_Sections[Section] = Allocate();
-			if (m_Sections[Section] == NULL)
-			{
-				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
-				return;
-			}
-			ZeroSection(m_Sections[Section]);
-		}
-		int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
-		m_Sections[Section]->m_BlockTypes[Index] = a_Block;
-	}
-
-	NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
-	{
-		if (
-			(a_RelX < cChunkDef::Width) && (a_RelX > -1) &&
-			(a_RelY < cChunkDef::Height) && (a_RelY > -1) &&
-			(a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
-		{
-			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if (m_Sections[Section] != NULL)
-			{
-				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
-				return (m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
-			}
-			else
-			{
-				return 0;
-			}
-		}
-		ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!");
-		return 0;
-	}
-	
-	bool SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble)
-	{
-		if (
-			(a_RelX >= cChunkDef::Width)  || (a_RelX < 0) ||
-			(a_RelY >= cChunkDef::Height) || (a_RelY < 0) ||
-			(a_RelZ >= cChunkDef::Width)  || (a_RelZ < 0)
-		)
-		{
-			ASSERT(!"cChunkData::SetMeta(): index out of range!");
-			return false;
-		}
+	BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const;
+	void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block);
 
-		int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-		if (m_Sections[Section] == NULL)
-		{
-			if ((a_Nibble & 0xf) == 0x00)
-			{
-				return false;
-			}
-			m_Sections[Section] = Allocate();
-			if (m_Sections[Section] == NULL)
-			{
-				ASSERT(!"Failed to allocate a new section in Chunkbuffer");
-				return false;
-			}
-			ZeroSection(m_Sections[Section]);
-		}
-		int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
-		NIBBLETYPE oldval = m_Sections[Section]->m_BlockMeta[Index / 2] >> ((Index & 1) * 4) & 0xf;
-		m_Sections[Section]->m_BlockMeta[Index / 2] = static_cast<NIBBLETYPE>(
-			(m_Sections[Section]->m_BlockMeta[Index / 2] & (0xf0 >> ((Index & 1) * 4))) |  // The untouched nibble
-			((a_Nibble & 0x0f) << ((Index & 1) * 4))  // The nibble being set
-		);
-		return oldval == a_Nibble;
-	}
+	NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const;
+	bool SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble);
 	
-	NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const
-	{
-		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
-		{
-			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if (m_Sections[Section] != NULL)
-			{
-				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
-				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
-			}
-			else
-			{
-				return 0;
-			}
-		}
-		ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!");
-		return 0;
-	}
+	NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const;
 	
-	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const
-	{
-		if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
-		{
-			int Section = a_RelY / CHUNK_SECTION_HEIGHT;
-			if (m_Sections[Section] != NULL)
-			{
-				int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY - (Section * CHUNK_SECTION_HEIGHT), a_RelZ);
-				return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
-			}
-			else
-			{
-				return 0xF;
-			}
-		}
-		ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!");
-		return 0;
-	}
+	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const;
 	
 	cChunkData Copy() const;
 	void CopyBlocks   (BLOCKTYPE * a_dest, size_t a_Idx = 0, size_t length = cChunkDef::NumBlocks)  const;
-- 
cgit v1.2.3


From 7ec44951a0841734be53e81088dcdbc79a104d02 Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Wed, 28 May 2014 11:35:55 +0200
Subject: Fixed cChunkData formatting.

---
 src/ChunkData.h | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 16fcc4d37..6544b246e 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -25,12 +25,12 @@ public:
 	
 	#if __cplusplus < 201103L
 		// auto_ptr style interface for memory management
-		cChunkData(const cChunkData& other);
-		cChunkData& operator=(const cChunkData& other);
+		cChunkData(const cChunkData & other);
+		cChunkData & operator =(const cChunkData & other);
 	#else
 		// unique_ptr style interface for memory management
-		cChunkData(cChunkData&& other);
-		cChunkData& operator=(cChunkData&& other);
+		cChunkData(cChunkData && other);
+		cChunkData & operator =(cChunkData && other);
 	#endif
 
 	BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const;
@@ -43,15 +43,15 @@ public:
 	
 	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const;
 	
-	cChunkData Copy() const;
+	cChunkData Copy(void) const;
 	void CopyBlocks   (BLOCKTYPE * a_dest, size_t a_Idx = 0, size_t length = cChunkDef::NumBlocks)  const;
 	void CopyMeta     (NIBBLETYPE * a_dest) const;
-	void CopyBlockLight    (NIBBLETYPE * a_dest) const;
+	void CopyBlockLight(NIBBLETYPE * a_dest) const;
 	void CopySkyLight (NIBBLETYPE * a_dest) const;
 	
 	void SetBlocks    (const BLOCKTYPE * a_src);
 	void SetMeta      (const NIBBLETYPE * a_src);
-	void SetBlockLight     (const NIBBLETYPE * a_src);
+	void SetBlockLight(const NIBBLETYPE * a_src);
 	void SetSkyLight  (const NIBBLETYPE * a_src);
 	
 private:
@@ -61,19 +61,19 @@ private:
 
 	#if __cplusplus < 201103L
 	// auto_ptr style interface for memory management
-	mutable bool IsOwner;
+	mutable bool m_IsOwner;
 	#endif
 	
 	struct sChunkSection {
-		BLOCKTYPE  m_BlockTypes   [CHUNK_SECTION_HEIGHT * 16 * 16]    ;
+		BLOCKTYPE  m_BlockTypes   [CHUNK_SECTION_HEIGHT * 16 * 16];
 		NIBBLETYPE m_BlockMeta    [CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
 		NIBBLETYPE m_BlockLight   [CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
 		NIBBLETYPE m_BlockSkyLight[CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
 	};
 	
-	sChunkSection *m_Sections[CHUNK_SECTION_COUNT];
+	sChunkSection * m_Sections[CHUNK_SECTION_COUNT];
 	
-	sChunkSection * Allocate() const;
+	sChunkSection * Allocate(void) const;
 	void Free(sChunkSection * ptr) const;
 	
 	void ZeroSection(sChunkSection * ptr) const;
-- 
cgit v1.2.3


From 81f756cbda76507cc676fd50f20f33483c4ce6f8 Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Wed, 28 May 2014 22:40:19 +0200
Subject: cChunkData: Normalized code style.

---
 src/ChunkData.h | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 6544b246e..09b2cb563 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -25,12 +25,12 @@ public:
 	
 	#if __cplusplus < 201103L
 		// auto_ptr style interface for memory management
-		cChunkData(const cChunkData & other);
-		cChunkData & operator =(const cChunkData & other);
+		cChunkData(const cChunkData & a_Other);
+		cChunkData & operator =(const cChunkData & a_Other);
 	#else
 		// unique_ptr style interface for memory management
-		cChunkData(cChunkData && other);
-		cChunkData & operator =(cChunkData && other);
+		cChunkData(cChunkData && a_Other);
+		cChunkData & operator =(cChunkData && a_ther);
 	#endif
 
 	BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const;
@@ -44,10 +44,10 @@ public:
 	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const;
 	
 	cChunkData Copy(void) const;
-	void CopyBlocks   (BLOCKTYPE * a_dest, size_t a_Idx = 0, size_t length = cChunkDef::NumBlocks)  const;
-	void CopyMeta     (NIBBLETYPE * a_dest) const;
-	void CopyBlockLight(NIBBLETYPE * a_dest) const;
-	void CopySkyLight (NIBBLETYPE * a_dest) const;
+	void CopyBlocks    (BLOCKTYPE * a_Dest, size_t a_Idx = 0, size_t a_Length = cChunkDef::NumBlocks) const;
+	void CopyMeta      (NIBBLETYPE * a_Dest) const;
+	void CopyBlockLight(NIBBLETYPE * a_Dest) const;
+	void CopySkyLight  (NIBBLETYPE * a_Dest) const;
 	
 	void SetBlocks    (const BLOCKTYPE * a_src);
 	void SetMeta      (const NIBBLETYPE * a_src);
@@ -73,10 +73,15 @@ private:
 	
 	sChunkSection * m_Sections[CHUNK_SECTION_COUNT];
 	
-	sChunkSection * Allocate(void) const;
-	void Free(sChunkSection * ptr) const;
+	/** Allocates a new section. Entry-point to custom allocators. */
+	static sChunkSection * Allocate(void);
 	
-	void ZeroSection(sChunkSection * ptr) const;
+	/** Frees the specified section, previously allocated using Allocate().
+	Note that a_Section may be NULL. */
+	static void Free(sChunkSection * a_Section);
+	
+	/** Sets the data in the specified section to their default values. */
+	void ZeroSection(sChunkSection * a_Section) const;
 };
 
 
-- 
cgit v1.2.3


From d9c667d28f556e489b2779b7510f3b12034c3fad Mon Sep 17 00:00:00 2001
From: worktycho <work.tycho@gmail.com>
Date: Thu, 29 May 2014 12:04:37 +0100
Subject: Add comment

---
 src/ChunkData.h | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 09b2cb563..e6aaa99b8 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -44,6 +44,10 @@ public:
 	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const;
 	
 	cChunkData Copy(void) const;
+	
+	// Copys data from this object into the buffer in the a_Dest param
+	// CopyBlocks also povides the optional parameters a_Idx and a_Length which specify an offset and length for
+	// copying part of the BlockTypes array.
 	void CopyBlocks    (BLOCKTYPE * a_Dest, size_t a_Idx = 0, size_t a_Length = cChunkDef::NumBlocks) const;
 	void CopyMeta      (NIBBLETYPE * a_Dest) const;
 	void CopyBlockLight(NIBBLETYPE * a_Dest) const;
-- 
cgit v1.2.3


From f7777e8c7559964f126a64af7673276e356dcedc Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Thu, 29 May 2014 18:25:08 +0200
Subject: Added comments, reformatted code.

---
 src/ChunkData.h | 65 ++++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 48 insertions(+), 17 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index e6aaa99b8..341c15301 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -1,4 +1,12 @@
 
+// ChunkData.h
+
+// Declares the cChunkData class that represents the block's type, meta, blocklight and skylight storage for a chunk
+
+
+
+
+
 #pragma once
 
 
@@ -20,7 +28,7 @@ class cChunkData
 {
 public:
 
-	cChunkData();
+	cChunkData(void);
 	~cChunkData();
 	
 	#if __cplusplus < 201103L
@@ -43,25 +51,48 @@ public:
 	
 	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const;
 	
+	/** Creates a (deep) copy of self. */
 	cChunkData Copy(void) const;
 	
-	// Copys data from this object into the buffer in the a_Dest param
-	// CopyBlocks also povides the optional parameters a_Idx and a_Length which specify an offset and length for
-	// copying part of the BlockTypes array.
-	void CopyBlocks    (BLOCKTYPE * a_Dest, size_t a_Idx = 0, size_t a_Length = cChunkDef::NumBlocks) const;
-	void CopyMeta      (NIBBLETYPE * a_Dest) const;
+	/** Copies the blocktype data into the specified flat array.
+	Optionally, only a part of the data is copied, as specified by the a_Idx and a_Length parameters. */
+	void CopyBlockTypes(BLOCKTYPE * a_Dest, size_t a_Idx = 0, size_t a_Length = cChunkDef::NumBlocks) const;
+	
+	/** Copies the metadata into the specified flat array. */
+	void CopyMetas(NIBBLETYPE * a_Dest) const;
+	
+	/** Copies the block light data into the specified flat array. */
 	void CopyBlockLight(NIBBLETYPE * a_Dest) const;
+	
+	/** Copies the skylight data into the specified flat array. */
 	void CopySkyLight  (NIBBLETYPE * a_Dest) const;
 	
-	void SetBlocks    (const BLOCKTYPE * a_src);
-	void SetMeta      (const NIBBLETYPE * a_src);
-	void SetBlockLight(const NIBBLETYPE * a_src);
-	void SetSkyLight  (const NIBBLETYPE * a_src);
+	/** Copies the blocktype data from the specified flat array into the internal representation.
+	Allocates sections that are needed for the operation.
+	Requires that a_Src is a valid pointer. */
+	void SetBlockTypes(const BLOCKTYPE * a_Src);
+	
+	/** Copies the metadata from the specified flat array into the internal representation.
+	Allocates sectios that are needed for the operation.
+	Requires that a_Src is a valid pointer. */
+	void SetMetas(const NIBBLETYPE * a_Src);
+	
+	/** Copies the blocklight data from the specified flat array into the internal representation.
+	Allocates sectios that are needed for the operation.
+	Allows a_Src to be NULL, in which case it doesn't do anything. */
+	void SetBlockLight(const NIBBLETYPE * a_Src);
+
+	/** Copies the skylight data from the specified flat array into the internal representation.
+	Allocates sectios that are needed for the operation.
+	Allows a_Src to be NULL, in which case it doesn't do anything. */
+	void SetSkyLight(const NIBBLETYPE * a_Src);
 	
 private:
 
-	static const size_t CHUNK_SECTION_HEIGHT = 16;
-	static const size_t CHUNK_SECTION_COUNT = (256 / CHUNK_SECTION_HEIGHT);
+	static const size_t SectionHeight = 16;
+	static const size_t NumSections = (cChunkDef::Height / SectionHeight);
+	static const size_t SegmentLength = cChunkDef::Width * cChunkDef::Height * SectionHeight;
+	static const size_t SectionBlockCount = SectionHeight * cChunkDef::Width * cChunkDef::Width;
 
 	#if __cplusplus < 201103L
 	// auto_ptr style interface for memory management
@@ -69,13 +100,13 @@ private:
 	#endif
 	
 	struct sChunkSection {
-		BLOCKTYPE  m_BlockTypes   [CHUNK_SECTION_HEIGHT * 16 * 16];
-		NIBBLETYPE m_BlockMeta    [CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
-		NIBBLETYPE m_BlockLight   [CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
-		NIBBLETYPE m_BlockSkyLight[CHUNK_SECTION_HEIGHT * 16 * 16 / 2];
+		BLOCKTYPE  m_BlockTypes   [SectionBlockCount];
+		NIBBLETYPE m_BlockMeta    [SectionBlockCount / 2];
+		NIBBLETYPE m_BlockLight   [SectionBlockCount / 2];
+		NIBBLETYPE m_BlockSkyLight[SectionBlockCount / 2];
 	};
 	
-	sChunkSection * m_Sections[CHUNK_SECTION_COUNT];
+	sChunkSection * m_Sections[NumSections];
 	
 	/** Allocates a new section. Entry-point to custom allocators. */
 	static sChunkSection * Allocate(void);
-- 
cgit v1.2.3


From 59068b77b7215461b4aaf11c2db91c1657b7f91d Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Thu, 29 May 2014 20:18:37 +0200
Subject: Fixed wrong block sizes for copying / setting.

---
 src/ChunkData.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index 341c15301..fef31b5ad 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -91,7 +91,6 @@ private:
 
 	static const size_t SectionHeight = 16;
 	static const size_t NumSections = (cChunkDef::Height / SectionHeight);
-	static const size_t SegmentLength = cChunkDef::Width * cChunkDef::Height * SectionHeight;
 	static const size_t SectionBlockCount = SectionHeight * cChunkDef::Width * cChunkDef::Width;
 
 	#if __cplusplus < 201103L
@@ -101,7 +100,7 @@ private:
 	
 	struct sChunkSection {
 		BLOCKTYPE  m_BlockTypes   [SectionBlockCount];
-		NIBBLETYPE m_BlockMeta    [SectionBlockCount / 2];
+		NIBBLETYPE m_BlockMetas   [SectionBlockCount / 2];
 		NIBBLETYPE m_BlockLight   [SectionBlockCount / 2];
 		NIBBLETYPE m_BlockSkyLight[SectionBlockCount / 2];
 	};
-- 
cgit v1.2.3


From ee50790398791c38e563eee04cf12780fab74baf Mon Sep 17 00:00:00 2001
From: Tycho <work.tycho+git@gmail.com>
Date: Mon, 16 Jun 2014 15:12:50 +0100
Subject: Merge branch 'master' of github.com:mc-server/MCServer

---
 src/ChunkData.h | 54 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 23 deletions(-)

(limited to 'src/ChunkData.h')

diff --git a/src/ChunkData.h b/src/ChunkData.h
index fef31b5ad..fe8b068a2 100644
--- a/src/ChunkData.h
+++ b/src/ChunkData.h
@@ -15,6 +15,7 @@
 
 #include "ChunkDef.h"
 
+#include "AllocationPool.h"
 
 
 
@@ -26,9 +27,17 @@
 
 class cChunkData
 {
+private:
+
+	static const size_t SectionHeight = 16;
+	static const size_t NumSections = (cChunkDef::Height / SectionHeight);
+	static const size_t SectionBlockCount = SectionHeight * cChunkDef::Width * cChunkDef::Width;
+
 public:
 
-	cChunkData(void);
+	struct sChunkSection;
+
+	cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool);
 	~cChunkData();
 	
 	#if __cplusplus < 201103L
@@ -53,17 +62,17 @@ public:
 	
 	/** Creates a (deep) copy of self. */
 	cChunkData Copy(void) const;
-	
+
 	/** Copies the blocktype data into the specified flat array.
 	Optionally, only a part of the data is copied, as specified by the a_Idx and a_Length parameters. */
 	void CopyBlockTypes(BLOCKTYPE * a_Dest, size_t a_Idx = 0, size_t a_Length = cChunkDef::NumBlocks) const;
-	
+
 	/** Copies the metadata into the specified flat array. */
 	void CopyMetas(NIBBLETYPE * a_Dest) const;
-	
+
 	/** Copies the block light data into the specified flat array. */
 	void CopyBlockLight(NIBBLETYPE * a_Dest) const;
-	
+
 	/** Copies the skylight data into the specified flat array. */
 	void CopySkyLight  (NIBBLETYPE * a_Dest) const;
 	
@@ -71,12 +80,12 @@ public:
 	Allocates sections that are needed for the operation.
 	Requires that a_Src is a valid pointer. */
 	void SetBlockTypes(const BLOCKTYPE * a_Src);
-	
+
 	/** Copies the metadata from the specified flat array into the internal representation.
 	Allocates sectios that are needed for the operation.
 	Requires that a_Src is a valid pointer. */
 	void SetMetas(const NIBBLETYPE * a_Src);
-	
+
 	/** Copies the blocklight data from the specified flat array into the internal representation.
 	Allocates sectios that are needed for the operation.
 	Allows a_Src to be NULL, in which case it doesn't do anything. */
@@ -86,36 +95,35 @@ public:
 	Allocates sectios that are needed for the operation.
 	Allows a_Src to be NULL, in which case it doesn't do anything. */
 	void SetSkyLight(const NIBBLETYPE * a_Src);
+
+	struct sChunkSection
+	{
+		BLOCKTYPE  m_BlockTypes   [SectionHeight * 16 * 16]    ;
+		NIBBLETYPE m_BlockMetas   [SectionHeight * 16 * 16 / 2];
+		NIBBLETYPE m_BlockLight   [SectionHeight * 16 * 16 / 2];
+		NIBBLETYPE m_BlockSkyLight[SectionHeight * 16 * 16 / 2];
+	};
 	
 private:
-
-	static const size_t SectionHeight = 16;
-	static const size_t NumSections = (cChunkDef::Height / SectionHeight);
-	static const size_t SectionBlockCount = SectionHeight * cChunkDef::Width * cChunkDef::Width;
-
 	#if __cplusplus < 201103L
 	// auto_ptr style interface for memory management
 	mutable bool m_IsOwner;
 	#endif
-	
-	struct sChunkSection {
-		BLOCKTYPE  m_BlockTypes   [SectionBlockCount];
-		NIBBLETYPE m_BlockMetas   [SectionBlockCount / 2];
-		NIBBLETYPE m_BlockLight   [SectionBlockCount / 2];
-		NIBBLETYPE m_BlockSkyLight[SectionBlockCount / 2];
-	};
-	
+
 	sChunkSection * m_Sections[NumSections];
+
+	cAllocationPool<cChunkData::sChunkSection> & m_Pool;
 	
 	/** Allocates a new section. Entry-point to custom allocators. */
-	static sChunkSection * Allocate(void);
-	
+	sChunkSection * Allocate(void);
+
 	/** Frees the specified section, previously allocated using Allocate().
 	Note that a_Section may be NULL. */
-	static void Free(sChunkSection * a_Section);
+	void Free(sChunkSection * a_Section);
 	
 	/** Sets the data in the specified section to their default values. */
 	void ZeroSection(sChunkSection * a_Section) const;
+
 };
 
 
-- 
cgit v1.2.3