Implement protocol level chunk sparsing (#3864)

src/ChunkData.cpp

@@ -27,16 +27,23 @@ template <typename T> inline bool IsAllValue(const T * a_Array, size_t a_NumElem
 
 
 
-cChunkData::cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool) :
+cChunkData::cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool):
-#if __cplusplus < 201103L
+	m_Sections(),
-	// auto_ptr style interface for memory management
-	m_IsOwner(true),
-#endif
 	m_Pool(a_Pool)
+{
+}
+
+
+
+
+
+cChunkData::cChunkData(cChunkData && a_Other):
+	m_Pool(a_Other.m_Pool)
 {
 	for (size_t i = 0; i < NumSections; i++)
 	{
-		m_Sections[i] = nullptr;
+		m_Sections[i] = a_Other.m_Sections[i];
+		a_Other.m_Sections[i] = nullptr;
 	}
 }
 
@@ -46,17 +53,29 @@ cChunkData::cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool) :
 
 cChunkData::~cChunkData()
 {
-	#if __cplusplus < 201103L
+	Clear();
-		// auto_ptr style interface for memory management
+}
-		if (!m_IsOwner)
+
-		{
+
-			return;
+
-		}
+
-	#endif
+
-	for (size_t i = 0; i < NumSections; i++)
+void cChunkData::Assign(const cChunkData & a_Other)
+{
+	// If assigning to self, no-op
+	if (&a_Other == this)
 	{
-		Free(m_Sections[i]);
+		return;
-		m_Sections[i] = nullptr;
+	}
+
+	Clear();
+	for (size_t i = 0; i < NumSections; ++i)
+	{
+		if (a_Other.m_Sections[i] != nullptr)
+		{
+			m_Sections[i] = Allocate();
+			*m_Sections[i] = *a_Other.m_Sections[i];
+		}
 	}
 }
 
@@ -64,85 +83,28 @@ cChunkData::~cChunkData()
 
 
 
-#if __cplusplus < 201103L
+void cChunkData::Assign(cChunkData && a_Other)
-	// auto_ptr style interface for memory management
+{
-	cChunkData::cChunkData(const cChunkData & a_Other) :
+	if (&a_Other == this)
-		m_IsOwner(true),
-		m_Pool(a_Other.m_Pool)
 	{
-		// Move contents and ownership from a_Other to this, pointer-wise:
+		return;
-		for (size_t i = 0; i < NumSections; i++)
-		{
-			m_Sections[i] = a_Other.m_Sections[i];
-		}
-		a_Other.m_IsOwner = false;
 	}
 
-
+	if (&m_Pool != &a_Other.m_Pool)
-
-
-
-	cChunkData & cChunkData::operator =(const cChunkData & a_Other)
 	{
-		// If assigning to self, no-op
+		// Cannot transfer the memory, do a copy instead
-		if (&a_Other == this)
+		const cChunkData & CopyOther = a_Other;
-		{
+		Assign(CopyOther);
-			return *this;
+		return;
-		}
-
-		// Free any currently held contents:
-		if (m_IsOwner)
-		{
-			for (size_t i = 0; i < NumSections; i++)
-			{
-				Free(m_Sections[i]);
-				m_Sections[i] = nullptr;
-			}
-		}
-
-		// Move contents and ownership from a_Other to this, pointer-wise:
-		m_IsOwner = true;
-		for (size_t i = 0; i < NumSections; i++)
-		{
-			m_Sections[i] = a_Other.m_Sections[i];
-		}
-		a_Other.m_IsOwner = false;
-		ASSERT(&m_Pool == &a_Other.m_Pool);
-		return *this;
 	}
 
-#else
+	Clear();
-
+	for (size_t i = 0; i < NumSections; i++)
-	// unique_ptr style interface for memory management
-	cChunkData::cChunkData(cChunkData && other) :
-	m_Pool(other.m_Pool)
 	{
-		for (size_t i = 0; i < NumSections; i++)
+		m_Sections[i] = a_Other.m_Sections[i];
-		{
+		a_Other.m_Sections[i] = nullptr;
-			m_Sections[i] = other.m_Sections[i];
-			other.m_Sections[i] = nullptr;
-		}
 	}
-
+}
-
-
-
-
-	cChunkData & cChunkData::operator =(cChunkData && other)
-	{
-		if (&other != this)
-		{
-			ASSERT(&m_Pool == &other.m_Pool);
-			for (size_t i = 0; i < NumSections; i++)
-			{
-				Free(m_Sections[i]);
-				m_Sections[i] = other.m_Sections[i];
-				other.m_Sections[i] = nullptr;
-			}
-		}
-		return *this;
-	}
-#endif
 
 
 
@@ -325,18 +287,45 @@ NIBBLETYPE cChunkData::GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const
 
 
 
-cChunkData cChunkData::Copy(void) const
+const cChunkData::sChunkSection * cChunkData::GetSection(size_t a_SectionNum) const
 {
-	cChunkData copy(m_Pool);
+	if (a_SectionNum < NumSections)
-	for (size_t i = 0; i < NumSections; i++)
+	{
+		return m_Sections[a_SectionNum];
+	}
+	ASSERT(!"cChunkData::GetSection: section index out of range");
+	return nullptr;
+}
+
+
+
+
+
+UInt16 cChunkData::GetSectionBitmask() const
+{
+	static_assert(NumSections <= 16U, "cChunkData::GetSectionBitmask needs a bigger data type");
+	UInt16 Res = 0U;
+	for (size_t i = 0U; i < NumSections; ++i)
+	{
+		Res |= ((m_Sections[i] != nullptr) << i);
+	}
+	return Res;
+}
+
+
+
+
+
+void cChunkData::Clear()
+{
+	for (size_t i = 0; i < NumSections; ++i)
 	{
 		if (m_Sections[i] != nullptr)
 		{
-			copy.m_Sections[i] = copy.Allocate();
+			Free(m_Sections[i]);
-			*copy.m_Sections[i] = *m_Sections[i];
+			m_Sections[i] = nullptr;
 		}
 	}
-	return copy;
 }
 
 
@@ -569,6 +558,23 @@ void cChunkData::SetSkyLight(const NIBBLETYPE * a_Src)
 
 
 
+UInt32 cChunkData::NumPresentSections() const
+{
+	UInt32 Ret = 0U;
+	for (size_t i = 0; i < NumSections; i++)
+	{
+		if (m_Sections[i] != nullptr)
+		{
+			++Ret;
+		}
+	}
+	return Ret;
+}
+
+
+
+
+
 cChunkData::sChunkSection * cChunkData::Allocate(void)
 {
 	return m_Pool.Allocate();

src/ChunkData.h

@@ -16,36 +16,37 @@
 
 
 
-#if __cplusplus < 201103L
-// auto_ptr style interface for memory management
-#else
-// unique_ptr style interface for memory management
-#endif
-
 class cChunkData
 {
-private:
+public:
 
 	static const int SectionHeight = 16;
 	static const size_t NumSections = (cChunkDef::Height / SectionHeight);
 	static const size_t SectionBlockCount = SectionHeight * cChunkDef::Width * cChunkDef::Width;
 
-public:
+	struct sChunkSection
+	{
+		BLOCKTYPE  m_BlockTypes[SectionBlockCount];
+		NIBBLETYPE m_BlockMetas[SectionBlockCount / 2];
+		NIBBLETYPE m_BlockLight[SectionBlockCount / 2];
+		NIBBLETYPE m_BlockSkyLight[SectionBlockCount / 2];
+	};
 
-	struct sChunkSection;
+	cChunkData(cAllocationPool<sChunkSection> & a_Pool);
-
+	cChunkData(cChunkData && a_Other);
-	cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool);
 	~cChunkData();
 
-	#if __cplusplus < 201103L
+	cChunkData & operator = (cChunkData && a_Other)
-		// auto_ptr style interface for memory management
+	{
-		cChunkData(const cChunkData & a_Other);
+		Assign(std::move(a_Other));
-		cChunkData & operator =(const cChunkData & a_Other);
+		return *this;
-	#else
+	}
-		// unique_ptr style interface for memory management
+
-		cChunkData(cChunkData && a_Other);
+	/** Copy assign from another cChunkData */
-		cChunkData & operator =(cChunkData && a_ther);
+	void Assign(const cChunkData & a_Other);
-	#endif
+
+	/** Move assign from another cChunkData */
+	void Assign(cChunkData && a_Other);
 
 	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);
@@ -57,8 +58,14 @@ public:
 
 	NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const;
 
-	/** Creates a (deep) copy of self. */
+	/** Return a pointer to the chunk section or nullptr if all air */
-	cChunkData Copy(void) const;
+	const sChunkSection * GetSection(size_t a_SectionNum) const;
+
+	/** Returns a bitmask of chunk sections which are currently stored. */
+	UInt16 GetSectionBitmask() const;
+
+	/** Clears all data */
+	void Clear();
 
 	/** 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. */
@@ -93,23 +100,14 @@ public:
 	Allows a_Src to be nullptr, in which case it doesn't do anything. */
 	void SetSkyLight(const NIBBLETYPE * a_Src);
 
-	struct sChunkSection
+	/** Returns the number of sections present (i.e. non-air). */
-	{
+	UInt32 NumPresentSections() const;
-		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:
-	#if __cplusplus < 201103L
-	// auto_ptr style interface for memory management
-	mutable bool m_IsOwner;
-	#endif
 
 	sChunkSection * m_Sections[NumSections];
 
-	cAllocationPool<cChunkData::sChunkSection> & m_Pool;
+	cAllocationPool<sChunkSection> & m_Pool;
 
 	/** Allocates a new section. Entry-point to custom allocators. */
 	sChunkSection * Allocate(void);

src/ChunkDataCallback.h

@@ -101,3 +101,37 @@ protected:
 
 
 
+/** A simple implementation of the cChunkDataCallback interface that just copies the cChunkData */
+class cChunkDataCopyCollector :
+	public cChunkDataCallback
+{
+public:
+	struct MemCallbacks:
+		cAllocationPool<cChunkData::sChunkSection>::cStarvationCallbacks
+	{
+		virtual void OnStartUsingReserve() override {}
+		virtual void OnEndUsingReserve() override {}
+		virtual void OnOutOfReserve() override {}
+	};
+
+	cChunkDataCopyCollector():
+		m_Pool(cpp14::make_unique<MemCallbacks>()),
+		m_Data(m_Pool)
+	{
+	}
+
+
+	cListAllocationPool<cChunkData::sChunkSection, cChunkData::NumSections> m_Pool;  // Keep 1 chunk worth of reserve
+	cChunkData m_Data;
+
+protected:
+
+	virtual void ChunkData(const cChunkData & a_ChunkBuffer) override
+	{
+		m_Data.Assign(a_ChunkBuffer);
+	}
+};
+
+
+
+

src/ChunkSender.cpp

@@ -257,7 +257,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, std::unordered_set<cCli
 	{
 		return;
 	}
-	cChunkDataSerializer Data(m_BlockTypes, m_BlockMetas, m_BlockLight, m_BlockSkyLight, m_BiomeMap, m_World.GetDimension());
+	cChunkDataSerializer Data(m_Data, m_BiomeMap, m_World.GetDimension());
 
 	for (const auto client : a_Clients)
 	{
@@ -271,6 +271,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, std::unordered_set<cCli
 		}  // for itr - m_Packets[]
 
 	}
+	m_Data.Clear();
 	m_BlockEntities.clear();
 
 	// TODO: Send entity spawn packets

src/ChunkSender.h

@@ -51,7 +51,7 @@ class cChunkSender;
 
 class cChunkSender:
 	public cIsThread,
-	public cChunkDataSeparateCollector
+	public cChunkDataCopyCollector
 {
 	typedef cIsThread super;
 public:

src/Protocol/ChunkDataSerializer.cpp

@@ -15,18 +15,34 @@
 
 
 
+
+/** Calls the given function with every present chunk section. */
+template <class Func>
+void ForEachSection(const cChunkData & a_Data, Func a_Func)
+{
+	for (size_t SectionIdx = 0; SectionIdx < cChunkData::NumSections; ++SectionIdx)
+	{
+		auto Section = a_Data.GetSection(SectionIdx);
+		if (Section != nullptr)
+		{
+			a_Func(*Section);
+		}
+	}
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cChunkDataSerializer:
+
 cChunkDataSerializer::cChunkDataSerializer(
-	const cChunkDef::BlockTypes   & a_BlockTypes,
+	const cChunkData &    a_Data,
-	const cChunkDef::BlockNibbles & a_BlockMetas,
+	const unsigned char * a_BiomeData,
-	const cChunkDef::BlockNibbles & a_BlockLight,
+	const eDimension      a_Dimension
-	const cChunkDef::BlockNibbles & a_BlockSkyLight,
+):
-	const unsigned char *           a_BiomeData,
+	m_Data(a_Data),
-	const eDimension a_Dimension
-) :
-	m_BlockTypes(a_BlockTypes),
-	m_BlockMetas(a_BlockMetas),
-	m_BlockLight(a_BlockLight),
-	m_BlockSkyLight(a_BlockSkyLight),
 	m_BiomeData(a_BiomeData),
 	m_Dimension(a_Dimension)
 {
@@ -35,6 +51,7 @@ cChunkDataSerializer::cChunkDataSerializer(
 
 
 
+
 const AString & cChunkDataSerializer::Serialize(int a_Version, int a_ChunkX, int a_ChunkZ)
 {
 	Serializations::const_iterator itr = m_Serializations.find(a_Version);
@@ -68,6 +85,7 @@ const AString & cChunkDataSerializer::Serialize(int a_Version, int a_ChunkX, int
 
 
 
+
 void cChunkDataSerializer::Serialize47(AString & a_Data, int a_ChunkX, int a_ChunkZ)
 {
 	// This function returns the fully compressed packet (including packet size), not the raw packet!
@@ -77,32 +95,49 @@ void cChunkDataSerializer::Serialize47(AString & a_Data, int a_ChunkX, int a_Chu
 	Packet.WriteVarInt32(0x21);  // Packet id (Chunk Data packet)
 	Packet.WriteBEInt32(a_ChunkX);
 	Packet.WriteBEInt32(a_ChunkZ);
-	Packet.WriteBool(true);        // "Ground-up continuous", or rather, "biome data present" flag
+	Packet.WriteBool(true);      // "Ground-up continuous", or rather, "biome data present" flag
-	Packet.WriteBEUInt16(0xffff);  // We're aways sending the full chunk with no additional data, so the bitmap is 0xffff
+	Packet.WriteBEUInt16(m_Data.GetSectionBitmask());
 
 	// Write the chunk size:
 	const int BiomeDataSize = cChunkDef::Width * cChunkDef::Width;
 	UInt32 ChunkSize = (
-		(cChunkDef::NumBlocks * 2) +  // Block meta + type
+		m_Data.NumPresentSections() * cChunkData::SectionBlockCount * 3 +  // Blocks and lighting
-		sizeof(m_BlockLight) +        // Block light
+		BiomeDataSize    // Biome data
-		sizeof(m_BlockSkyLight) +     // Block sky light
-		BiomeDataSize                 // Biome data
 	);
 	Packet.WriteVarInt32(ChunkSize);
 
-	// Write the block types to the packet:
+	// Chunk written as seperate arrays of (blocktype + meta), blocklight and skylight
-	for (size_t Index = 0; Index < cChunkDef::NumBlocks; Index++)
+	// each array stores all present sections of the same kind packed together
-	{
-		BLOCKTYPE BlockType = m_BlockTypes[Index] & 0xFF;
-		NIBBLETYPE BlockMeta = m_BlockMetas[Index / 2] >> ((Index & 1) * 4) & 0x0f;
-		Packet.WriteBEUInt8(static_cast<unsigned char>(BlockType << 4) | BlockMeta);
-		Packet.WriteBEUInt8(static_cast<unsigned char>(BlockType >> 4));
-	}
 
-	// Write the rest:
+	// Write the block types to the packet:
-	Packet.WriteBuf(m_BlockLight,    sizeof(m_BlockLight));
+	ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section)
-	Packet.WriteBuf(m_BlockSkyLight, sizeof(m_BlockSkyLight));
+		{
-	Packet.WriteBuf(m_BiomeData,     BiomeDataSize);
+			for (size_t BlockIdx = 0; BlockIdx != cChunkData::SectionBlockCount; ++BlockIdx)
+			{
+				BLOCKTYPE BlockType = a_Section.m_BlockTypes[BlockIdx] & 0xFF;
+				NIBBLETYPE BlockMeta = a_Section.m_BlockMetas[BlockIdx / 2] >> ((BlockIdx & 1) * 4) & 0x0f;
+				Packet.WriteBEUInt8(static_cast<unsigned char>(BlockType << 4) | BlockMeta);
+				Packet.WriteBEUInt8(static_cast<unsigned char>(BlockType >> 4));
+			}
+		}
+	);
+
+	// Write the block lights:
+	ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section)
+		{
+			Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight));
+		}
+	);
+
+	// Write the sky lights:
+	ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section)
+		{
+			Packet.WriteBuf(a_Section.m_BlockSkyLight, sizeof(a_Section.m_BlockSkyLight));
+		}
+	);
+
+	// Write the biome data:
+	Packet.WriteBuf(m_BiomeData, BiomeDataSize);
 
 	AString PacketData;
 	Packet.ReadAll(PacketData);
@@ -147,102 +182,92 @@ void cChunkDataSerializer::Serialize107(AString & a_Data, int a_ChunkX, int a_Ch
 	Packet.WriteBEInt32(a_ChunkX);
 	Packet.WriteBEInt32(a_ChunkZ);
 	Packet.WriteBool(true);        // "Ground-up continuous", or rather, "biome data present" flag
-	Packet.WriteVarInt32(0x0000ffff);  // We're aways sending the full chunk with no additional data, so the bitmap is 0xffff
+	Packet.WriteVarInt32(m_Data.GetSectionBitmask());
 	// Write the chunk size:
-	const size_t NumChunkSections = 16;
-	const size_t ChunkSectionBlocks = 16 * 16 * 16;
 	const size_t BitsPerEntry = 13;
 	const size_t Mask = (1 << BitsPerEntry) - 1;  // Creates a mask that is 13 bits long, ie 0b1111111111111
-	const size_t ChunkSectionDataArraySize = (ChunkSectionBlocks * BitsPerEntry) / 8 / 8;  // Convert from bit count to long count
+	const size_t ChunkSectionDataArraySize = (cChunkData::SectionBlockCount * BitsPerEntry) / 8 / 8;  // Convert from bit count to long count
 	size_t ChunkSectionSize = (
-		1 +                                      // Bits per block - set to 13, so the global palette is used and the palette has a length of 0
+		1 +                                // Bits per block - set to 13, so the global palette is used and the palette has a length of 0
-		1 +                                      // Palette length
+		1 +                                // Palette length
-		2 +                                      // Data array length VarInt - 2 bytes for the current value
+		2 +                                // Data array length VarInt - 2 bytes for the current value
-		ChunkSectionDataArraySize * 8 +          // Actual block data - multiplied by 8 because first number is longs
+		ChunkSectionDataArraySize * 8 +    // Actual block data - multiplied by 8 because first number is longs
-		sizeof(m_BlockLight) / NumChunkSections  // Block light
+		cChunkData::SectionBlockCount / 2  // Block light
 	);
 
 	if (m_Dimension == dimOverworld)
 	{
 		// Sky light is only sent in the overworld.
-		ChunkSectionSize += sizeof(m_BlockSkyLight) / NumChunkSections;
+		ChunkSectionSize += cChunkData::SectionBlockCount / 2;
 	}
 
 	const size_t BiomeDataSize = cChunkDef::Width * cChunkDef::Width;
 	size_t ChunkSize = (
-		ChunkSectionSize * 16 +
+		ChunkSectionSize * m_Data.NumPresentSections() +
 		BiomeDataSize
 	);
 	Packet.WriteVarInt32(static_cast<UInt32>(ChunkSize));
 
 	// Write each chunk section...
-	for (size_t SectionIndex = 0; SectionIndex < 16; SectionIndex++)
+	ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section)
-	{
-		Packet.WriteBEUInt8(BitsPerEntry);
-		Packet.WriteVarInt32(0);  // Palette length is 0
-		Packet.WriteVarInt32(static_cast<UInt32>(ChunkSectionDataArraySize));
-
-		size_t StartIndex = SectionIndex * ChunkSectionBlocks;
-
-		UInt64 TempLong = 0;  // Temporary value that will be stored into
-		UInt64 CurrentlyWrittenIndex = 0;  // "Index" of the long that would be written to
-
-		for (size_t Index = 0; Index < ChunkSectionBlocks; Index++)
 		{
-			UInt64 Value = static_cast<UInt64>(m_BlockTypes[StartIndex + Index] << 4);
+			Packet.WriteBEUInt8(BitsPerEntry);
-			if (Index % 2 == 0)
+			Packet.WriteVarInt32(0);  // Palette length is 0
+			Packet.WriteVarInt32(static_cast<UInt32>(ChunkSectionDataArraySize));
+
+			UInt64 TempLong = 0;  // Temporary value that will be stored into
+			UInt64 CurrentlyWrittenIndex = 0;  // "Index" of the long that would be written to
+
+			for (size_t Index = 0; Index < cChunkData::SectionBlockCount; Index++)
 			{
-				Value |= m_BlockMetas[(StartIndex + Index) / 2] & 0x0f;
+				UInt64 Value = static_cast<UInt64>(a_Section.m_BlockTypes[Index] << 4);
+				if (Index % 2 == 0)
+				{
+					Value |= a_Section.m_BlockMetas[Index / 2] & 0x0f;
+				}
+				else
+				{
+					Value |= a_Section.m_BlockMetas[Index / 2] >> 4;
+				}
+				Value &= Mask;  // It shouldn't go out of bounds, but it's still worth being careful
+
+				// Painful part where we write data into the long array.  Based off of the normal code.
+				size_t BitPosition = Index * BitsPerEntry;
+				size_t FirstIndex = BitPosition / 64;
+				size_t SecondIndex = ((Index + 1) * BitsPerEntry - 1) / 64;
+				size_t BitOffset = BitPosition % 64;
+
+				if (FirstIndex != CurrentlyWrittenIndex)
+				{
+					// Write the current data before modifiying it.
+					Packet.WriteBEUInt64(TempLong);
+					TempLong = 0;
+					CurrentlyWrittenIndex = FirstIndex;
+				}
+
+				TempLong |= (Value << BitOffset);
+
+				if (FirstIndex != SecondIndex)
+				{
+					// Part of the data is now in the second long; write the first one first
+					Packet.WriteBEUInt64(TempLong);
+					CurrentlyWrittenIndex = SecondIndex;
+
+					TempLong = (Value >> (64 - BitOffset));
+				}
 			}
-			else
+			// The last long will generally not be written
+			Packet.WriteBEUInt64(TempLong);
+
+			// Write lighting:
+			Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight));
+			if (m_Dimension == dimOverworld)
 			{
-				Value |= m_BlockMetas[(StartIndex + Index) / 2] >> 4;
+				// Skylight is only sent in the overworld; the nether and end do not use it
-			}
+				Packet.WriteBuf(a_Section.m_BlockSkyLight, sizeof(a_Section.m_BlockSkyLight));
-			Value &= Mask;  // It shouldn't go out of bounds, but it's still worth being careful
-
-			// Painful part where we write data into the long array.  Based off of the normal code.
-			size_t BitPosition = Index * BitsPerEntry;
-			size_t FirstIndex = BitPosition / 64;
-			size_t SecondIndex = ((Index + 1) * BitsPerEntry - 1) / 64;
-			size_t BitOffset = BitPosition % 64;
-
-			if (FirstIndex != CurrentlyWrittenIndex)
-			{
-				// Write the current data before modifiying it.
-				Packet.WriteBEUInt64(TempLong);
-				TempLong = 0;
-				CurrentlyWrittenIndex = FirstIndex;
-			}
-
-			TempLong |= (Value << BitOffset);
-
-			if (FirstIndex != SecondIndex)
-			{
-				// Part of the data is now in the second long; write the first one first
-				Packet.WriteBEUInt64(TempLong);
-				CurrentlyWrittenIndex = SecondIndex;
-
-				TempLong = (Value >> (64 - BitOffset));
 			}
 		}
-		// The last long will generally not be written
+	);
-		Packet.WriteBEUInt64(TempLong);
-
-		// Light - stored as a nibble, so we need half sizes
-		// As far as I know, there isn't a method to only write a range of the array
-		for (size_t Index = 0; Index < ChunkSectionBlocks / 2; Index++)
-		{
-			Packet.WriteBEUInt8(m_BlockLight[(StartIndex / 2) + Index]);
-		}
-		if (m_Dimension == dimOverworld)
-		{
-			// Skylight is only sent in the overworld; the nether and end do not use it
-			for (size_t Index = 0; Index < ChunkSectionBlocks / 2; Index++)
-			{
-				Packet.WriteBEUInt8(m_BlockSkyLight[(StartIndex / 2) + Index]);
-			}
-		}
-	}
 
 	// Write the biome data
 	Packet.WriteBuf(m_BiomeData, BiomeDataSize);
@@ -290,102 +315,92 @@ void cChunkDataSerializer::Serialize110(AString & a_Data, int a_ChunkX, int a_Ch
 	Packet.WriteBEInt32(a_ChunkX);
 	Packet.WriteBEInt32(a_ChunkZ);
 	Packet.WriteBool(true);        // "Ground-up continuous", or rather, "biome data present" flag
-	Packet.WriteVarInt32(0x0000ffff);  // We're aways sending the full chunk with no additional data, so the bitmap is 0xffff
+	Packet.WriteVarInt32(m_Data.GetSectionBitmask());
 	// Write the chunk size:
-	const size_t NumChunkSections = 16;
-	const size_t ChunkSectionBlocks = 16 * 16 * 16;
 	const size_t BitsPerEntry = 13;
 	const size_t Mask = (1 << BitsPerEntry) - 1;  // Creates a mask that is 13 bits long, ie 0b1111111111111
-	const size_t ChunkSectionDataArraySize = (ChunkSectionBlocks * BitsPerEntry) / 8 / 8;  // Convert from bit count to long count
+	const size_t ChunkSectionDataArraySize = (cChunkData::SectionBlockCount * BitsPerEntry) / 8 / 8;  // Convert from bit count to long count
 	size_t ChunkSectionSize = (
-		1 +                                      // Bits per block - set to 13, so the global palette is used and the palette has a length of 0
+		1 +                                // Bits per block - set to 13, so the global palette is used and the palette has a length of 0
-		1 +                                      // Palette length
+		1 +                                // Palette length
-		2 +                                      // Data array length VarInt - 2 bytes for the current value
+		2 +                                // Data array length VarInt - 2 bytes for the current value
-		ChunkSectionDataArraySize * 8 +          // Actual block data - multiplied by 8 because first number is longs
+		ChunkSectionDataArraySize * 8 +    // Actual block data - multiplied by 8 because first number is longs
-		sizeof(m_BlockLight) / NumChunkSections  // Block light
+		cChunkData::SectionBlockCount / 2  // Block light
 	);
 
 	if (m_Dimension == dimOverworld)
 	{
 		// Sky light is only sent in the overworld.
-		ChunkSectionSize += sizeof(m_BlockSkyLight) / NumChunkSections;
+		ChunkSectionSize += cChunkData::SectionBlockCount / 2;
 	}
 
 	const size_t BiomeDataSize = cChunkDef::Width * cChunkDef::Width;
 	size_t ChunkSize = (
-		ChunkSectionSize * 16 +
+		ChunkSectionSize * m_Data.NumPresentSections() +
 		BiomeDataSize
 	);
 	Packet.WriteVarInt32(static_cast<UInt32>(ChunkSize));
 
 	// Write each chunk section...
-	for (size_t SectionIndex = 0; SectionIndex < 16; SectionIndex++)
+	ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section)
-	{
-		Packet.WriteBEUInt8(BitsPerEntry);
-		Packet.WriteVarInt32(0);  // Palette length is 0
-		Packet.WriteVarInt32(static_cast<UInt32>(ChunkSectionDataArraySize));
-
-		size_t StartIndex = SectionIndex * ChunkSectionBlocks;
-
-		UInt64 TempLong = 0;  // Temporary value that will be stored into
-		UInt64 CurrentlyWrittenIndex = 0;  // "Index" of the long that would be written to
-
-		for (size_t Index = 0; Index < ChunkSectionBlocks; Index++)
 		{
-			UInt64 Value = static_cast<UInt64>(m_BlockTypes[StartIndex + Index] << 4);
+			Packet.WriteBEUInt8(BitsPerEntry);
-			if (Index % 2 == 0)
+			Packet.WriteVarInt32(0);  // Palette length is 0
+			Packet.WriteVarInt32(static_cast<UInt32>(ChunkSectionDataArraySize));
+
+			UInt64 TempLong = 0;  // Temporary value that will be stored into
+			UInt64 CurrentlyWrittenIndex = 0;  // "Index" of the long that would be written to
+
+			for (size_t Index = 0; Index < cChunkData::SectionBlockCount; Index++)
 			{
-				Value |= m_BlockMetas[(StartIndex + Index) / 2] & 0x0f;
+				UInt64 Value = static_cast<UInt64>(a_Section.m_BlockTypes[Index] << 4);
+				if (Index % 2 == 0)
+				{
+					Value |= a_Section.m_BlockMetas[Index / 2] & 0x0f;
+				}
+				else
+				{
+					Value |= a_Section.m_BlockMetas[Index / 2] >> 4;
+				}
+				Value &= Mask;  // It shouldn't go out of bounds, but it's still worth being careful
+
+				// Painful part where we write data into the long array.  Based off of the normal code.
+				size_t BitPosition = Index * BitsPerEntry;
+				size_t FirstIndex = BitPosition / 64;
+				size_t SecondIndex = ((Index + 1) * BitsPerEntry - 1) / 64;
+				size_t BitOffset = BitPosition % 64;
+
+				if (FirstIndex != CurrentlyWrittenIndex)
+				{
+					// Write the current data before modifiying it.
+					Packet.WriteBEUInt64(TempLong);
+					TempLong = 0;
+					CurrentlyWrittenIndex = FirstIndex;
+				}
+
+				TempLong |= (Value << BitOffset);
+
+				if (FirstIndex != SecondIndex)
+				{
+					// Part of the data is now in the second long; write the first one first
+					Packet.WriteBEUInt64(TempLong);
+					CurrentlyWrittenIndex = SecondIndex;
+
+					TempLong = (Value >> (64 - BitOffset));
+				}
 			}
-			else
+			// The last long will generally not be written
+			Packet.WriteBEUInt64(TempLong);
+
+			// Write lighting:
+			Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight));
+			if (m_Dimension == dimOverworld)
 			{
-				Value |= m_BlockMetas[(StartIndex + Index) / 2] >> 4;
+				// Skylight is only sent in the overworld; the nether and end do not use it
-			}
+				Packet.WriteBuf(a_Section.m_BlockSkyLight, sizeof(a_Section.m_BlockSkyLight));
-			Value &= Mask;  // It shouldn't go out of bounds, but it's still worth being careful
-
-			// Painful part where we write data into the long array.  Based off of the normal code.
-			size_t BitPosition = Index * BitsPerEntry;
-			size_t FirstIndex = BitPosition / 64;
-			size_t SecondIndex = ((Index + 1) * BitsPerEntry - 1) / 64;
-			size_t BitOffset = BitPosition % 64;
-
-			if (FirstIndex != CurrentlyWrittenIndex)
-			{
-				// Write the current data before modifiying it.
-				Packet.WriteBEUInt64(TempLong);
-				TempLong = 0;
-				CurrentlyWrittenIndex = FirstIndex;
-			}
-
-			TempLong |= (Value << BitOffset);
-
-			if (FirstIndex != SecondIndex)
-			{
-				// Part of the data is now in the second long; write the first one first
-				Packet.WriteBEUInt64(TempLong);
-				CurrentlyWrittenIndex = SecondIndex;
-
-				TempLong = (Value >> (64 - BitOffset));
 			}
 		}
-		// The last long will generally not be written
+	);
-		Packet.WriteBEUInt64(TempLong);
-
-		// Light - stored as a nibble, so we need half sizes
-		// As far as I know, there isn't a method to only write a range of the array
-		for (size_t Index = 0; Index < ChunkSectionBlocks / 2; Index++)
-		{
-			Packet.WriteBEUInt8(m_BlockLight[(StartIndex / 2) + Index]);
-		}
-		if (m_Dimension == dimOverworld)
-		{
-			// Skylight is only sent in the overworld; the nether and end do not use it
-			for (size_t Index = 0; Index < ChunkSectionBlocks / 2; Index++)
-			{
-				Packet.WriteBEUInt8(m_BlockSkyLight[(StartIndex / 2) + Index]);
-			}
-		}
-	}
 
 	// Write the biome data
 	Packet.WriteBuf(m_BiomeData, BiomeDataSize);

src/Protocol/ChunkDataSerializer.h

@@ -5,6 +5,7 @@
 //  - serialize chunk data to different protocol versions
 //  - cache such serialized data for multiple clients
 
+#include "ChunkData.h"
 
 
 
@@ -12,10 +13,7 @@
 class cChunkDataSerializer
 {
 protected:
-	const cChunkDef::BlockTypes   & m_BlockTypes;
+	const cChunkData & m_Data;
-	const cChunkDef::BlockNibbles & m_BlockMetas;
-	const cChunkDef::BlockNibbles & m_BlockLight;
-	const cChunkDef::BlockNibbles & m_BlockSkyLight;
 	const unsigned char * m_BiomeData;
 	const eDimension m_Dimension;
 
@@ -36,12 +34,9 @@ public:
 	} ;
 
 	cChunkDataSerializer(
-		const cChunkDef::BlockTypes   & a_BlockTypes,
+		const cChunkData &    a_Data,
-		const cChunkDef::BlockNibbles & a_BlockMetas,
+		const unsigned char * a_BiomeData,
-		const cChunkDef::BlockNibbles & a_BlockLight,
+		const eDimension      a_Dimension
-		const cChunkDef::BlockNibbles & a_BlockSkyLight,
-		const unsigned char *           a_BiomeData,
-		const eDimension                a_Dimension
 	);
 
 	const AString & Serialize(int a_Version, int a_ChunkX, int a_ChunkZ);  // Returns one of the internal m_Serializations[]

tests/ChunkData/Copies.cpp

@@ -27,7 +27,8 @@ int main(int argc, char** argv)
 		buffer.SetBlock(3, 1, 4, 0xDE);
 		buffer.SetMeta(3, 1, 4, 0xA);
 	
-		cChunkData copy = buffer.Copy();
+		cChunkData copy(Pool);
+		copy.Assign(buffer);
 		testassert(copy.GetBlock(3, 1, 4) == 0xDE);
 		testassert(copy.GetMeta(3, 1, 4) == 0xA);