diff --git a/src/Protocol/ChunkDataSerializer.cpp b/src/Protocol/ChunkDataSerializer.cpp index 3a89bcd50..680b9139b 100644 --- a/src/Protocol/ChunkDataSerializer.cpp +++ b/src/Protocol/ChunkDataSerializer.cpp @@ -34,6 +34,33 @@ void ForEachSection(const cChunkData & a_Data, Func a_Func) +namespace +{ + auto PaletteLegacy(const BLOCKTYPE a_BlockType, const NIBBLETYPE a_Meta) + { + return (a_BlockType << 4) | a_Meta; + } + + auto Palette393(const BLOCKTYPE a_BlockType, const NIBBLETYPE a_Meta) + { + return Palette_1_13::FromBlock(PaletteUpgrade::FromBlock(a_BlockType, a_Meta)); + } + + auto Palette401(const BLOCKTYPE a_BlockType, const NIBBLETYPE a_Meta) + { + return Palette_1_13_1::FromBlock(PaletteUpgrade::FromBlock(a_BlockType, a_Meta)); + } + + auto Palette477(const BLOCKTYPE a_BlockType, const NIBBLETYPE a_Meta) + { + return Palette_1_14::FromBlock(PaletteUpgrade::FromBlock(a_BlockType, a_Meta)); + } +} + + + + + //////////////////////////////////////////////////////////////////////////////// // cChunkDataSerializer: @@ -95,13 +122,13 @@ void cChunkDataSerializer::SendToClients(const std::unordered_set(Entry.second); // This version didn't last very long xD + Serialize393<&Palette393>(Entry.second); // This version didn't last very long xD continue; } case cProtocol::Version::v1_13_1: case cProtocol::Version::v1_13_2: { - Serialize393<&Palette_1_13_1::FromBlock>(Entry.second); + Serialize393<&Palette401>(Entry.second); continue; } case cProtocol::Version::v1_14: @@ -111,8 +138,7 @@ void cChunkDataSerializer::SendToClients(const std::unordered_set & a_S Packet.WriteBool(true); // "Ground-up continuous", or rather, "biome data present" flag Packet.WriteVarInt32(m_Data.GetSectionBitmask()); // Write the chunk size: - const size_t BitsPerEntry = 13; - const size_t Mask = (1 << BitsPerEntry) - 1; // Creates a mask that is 13 bits long, ie 0b1111111111111 + const UInt8 BitsPerEntry = 13; 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 @@ -219,53 +244,10 @@ void cChunkDataSerializer::Serialize107(const std::vector & a_S // Write each chunk section... ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section) { - Packet.WriteBEUInt8(static_cast(BitsPerEntry)); + Packet.WriteBEUInt8(BitsPerEntry); Packet.WriteVarInt32(0); // Palette length is 0 Packet.WriteVarInt32(static_cast(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++) - { - UInt64 Value = static_cast(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)); - } - } - // The last long will generally not be written - Packet.WriteBEUInt64(TempLong); + WriteSectionDataSeamless<&PaletteLegacy>(Packet, a_Section, BitsPerEntry); // Write lighting: Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight)); @@ -299,8 +281,7 @@ void cChunkDataSerializer::Serialize110(const std::vector & a_S Packet.WriteBool(true); // "Ground-up continuous", or rather, "biome data present" flag Packet.WriteVarInt32(m_Data.GetSectionBitmask()); // Write the chunk size: - const size_t BitsPerEntry = 13; - const size_t Mask = (1 << BitsPerEntry) - 1; // Creates a mask that is 13 bits long, ie 0b1111111111111 + const UInt8 BitsPerEntry = 13; 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 @@ -326,53 +307,10 @@ void cChunkDataSerializer::Serialize110(const std::vector & a_S // Write each chunk section... ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section) { - Packet.WriteBEUInt8(static_cast(BitsPerEntry)); + Packet.WriteBEUInt8(BitsPerEntry); Packet.WriteVarInt32(0); // Palette length is 0 Packet.WriteVarInt32(static_cast(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++) - { - UInt64 Value = static_cast(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)); - } - } - // The last long will generally not be written - Packet.WriteBEUInt64(TempLong); + WriteSectionDataSeamless<&PaletteLegacy>(Packet, a_Section, BitsPerEntry); // Write lighting: Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight)); @@ -411,8 +349,7 @@ void cChunkDataSerializer::Serialize393(const std::vector & a_S Packet.WriteVarInt32(m_Data.GetSectionBitmask()); // Write the chunk size in bytes: - const size_t BitsPerEntry = 14; - const size_t Mask = (1 << BitsPerEntry) - 1; + const UInt8 BitsPerEntry = 14; const size_t ChunkSectionDataArraySize = (cChunkData::SectionBlockCount * BitsPerEntry) / 8 / 8; size_t ChunkSectionSize = ( 1 + // Bits per entry, BEUInt8, 1 byte @@ -437,46 +374,9 @@ void cChunkDataSerializer::Serialize393(const std::vector & a_S // Write each chunk section... ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section) { - Packet.WriteBEUInt8(static_cast(BitsPerEntry)); + Packet.WriteBEUInt8(BitsPerEntry); Packet.WriteVarInt32(static_cast(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++) - { - UInt32 blockType = a_Section.m_BlockTypes[Index]; - UInt32 blockMeta = (a_Section.m_BlockMetas[Index / 2] >> ((Index % 2) * 4)) & 0x0f; - UInt64 Value = Palette(PaletteUpgrade::FromBlock(blockType, blockMeta)); - 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); + WriteSectionDataSeamless(Packet, a_Section, BitsPerEntry); // Write lighting: Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight)); @@ -548,7 +448,7 @@ void cChunkDataSerializer::Serialize477(const std::vector & a_S Packet.WriteBEInt16(-1); Packet.WriteBEUInt8(BitsPerEntry); Packet.WriteVarInt32(static_cast(ChunkSectionDataArraySize)); - WriteSectionDataSeamless(Packet, a_Section, BitsPerEntry); + WriteSectionDataSeamless<&Palette477>(Packet, a_Section, BitsPerEntry); } ); @@ -568,6 +468,7 @@ void cChunkDataSerializer::Serialize477(const std::vector & a_S +template void cChunkDataSerializer::WriteSectionDataSeamless(cByteBuffer & a_Packet, const cChunkData::sChunkSection & a_Section, const UInt8 a_BitsPerEntry) { // https://wiki.vg/Chunk_Format#Data_structure @@ -582,7 +483,7 @@ void cChunkDataSerializer::WriteSectionDataSeamless(cByteBuffer & a_Packet, cons { const UInt32 BlockType = a_Section.m_BlockTypes[Index]; const UInt32 BlockMeta = (a_Section.m_BlockMetas[Index / 2] >> ((Index % 2) * 4)) & 0x0f; - const UInt32 Value = Palette_1_14::FromBlock(PaletteUpgrade::FromBlock(BlockType, BlockMeta)); + const UInt32 Value = Palette(BlockType, BlockMeta); // Write as much as possible of Value, starting from BitIndex, into Buffer: Buffer |= static_cast(Value) << BitIndex; diff --git a/src/Protocol/ChunkDataSerializer.h b/src/Protocol/ChunkDataSerializer.h index 98489d03d..f02bdd4d0 100644 --- a/src/Protocol/ChunkDataSerializer.h +++ b/src/Protocol/ChunkDataSerializer.h @@ -42,6 +42,7 @@ protected: /** Writes all blocks in a chunk section into a series of Int64. Writes start from the bit directly subsequent to the previous write's end, possibly crossing over to the next Int64. */ + template inline void WriteSectionDataSeamless(cByteBuffer & a_Packet, const cChunkData::sChunkSection & a_Section, const UInt8 a_BitsPerEntry); /** Finalises the data, compresses it if required, and delivers it to all clients. */