flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

cChunk and cChunkData: Use vectors for block get and set functions (#4172)

Browse Source 
* cChunkData: Change interface to use Vector3i
* cChunk: Add Vector3i overloads for bounded block get and set functions.
This commit is contained in:
peterbell10 2018-02-04 22:15:31 +00:00 committed by GitHub
parent d12804d4c0
commit 2df14a0496
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 243 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/BlockArea.cpp
View File

@ -2895,7 +2895,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
{ {
int InChunkX = BaseX + x; int InChunkX = BaseX + x;
int AreaX = OffX + x; int AreaX = OffX + x;
m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlock(InChunkX, InChunkY, InChunkZ); m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlock({ InChunkX, InChunkY, InChunkZ });
} // for x } // for x
} // for z } // for z
} // for y } // for y
@ -2916,7 +2916,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
{ {
int InChunkX = BaseX + x; int InChunkX = BaseX + x;
int AreaX = OffX + x; int AreaX = OffX + x;
m_Area.m_BlockMetas[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetMeta(InChunkX, InChunkY, InChunkZ); m_Area.m_BlockMetas[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetMeta({ InChunkX, InChunkY, InChunkZ });
} // for x } // for x
} // for z } // for z
} // for y } // for y
@ -2937,7 +2937,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
{ {
int InChunkX = BaseX + x; int InChunkX = BaseX + x;
int AreaX = OffX + x; int AreaX = OffX + x;
m_Area.m_BlockLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlockLight(InChunkX, InChunkY, InChunkZ); m_Area.m_BlockLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlockLight({ InChunkX, InChunkY, InChunkZ });
} // for x } // for x
} // for z } // for z
} // for y } // for y
@ -2958,7 +2958,7 @@ void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer)
{ {
int InChunkX = BaseX + x; int InChunkX = BaseX + x;
int AreaX = OffX + x; int AreaX = OffX + x;
m_Area.m_BlockSkyLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetSkyLight(InChunkX, InChunkY, InChunkZ); m_Area.m_BlockSkyLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetSkyLight({ InChunkX, InChunkY, InChunkZ });
} // for x } // for x
} // for z } // for z
} // for y } // for y

31
src/Chunk.cpp
View File

@ -1659,7 +1659,7 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
ASSERT(IsValid()); ASSERT(IsValid());
const BLOCKTYPE OldBlockType = GetBlock(a_RelX, a_RelY, a_RelZ); const BLOCKTYPE OldBlockType = GetBlock(a_RelX, a_RelY, a_RelZ);
const BLOCKTYPE OldBlockMeta = m_ChunkData.GetMeta(a_RelX, a_RelY, a_RelZ); const BLOCKTYPE OldBlockMeta = m_ChunkData.GetMeta({ a_RelX, a_RelY, a_RelZ });
if ((OldBlockType == a_BlockType) && (OldBlockMeta == a_BlockMeta)) if ((OldBlockType == a_BlockType) && (OldBlockMeta == a_BlockMeta))
{ {
return; return;
@ -1677,7 +1677,7 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
MarkDirty(); MarkDirty();
} }
m_ChunkData.SetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType); m_ChunkData.SetBlock({ a_RelX, a_RelY, a_RelZ }, a_BlockType);
// Queue block to be sent only if ... // Queue block to be sent only if ...
if ( if (
@ -1696,7 +1696,7 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta)); m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta));
} }
m_ChunkData.SetMeta(a_RelX, a_RelY, a_RelZ, a_BlockMeta); m_ChunkData.SetMeta({ a_RelX, a_RelY, a_RelZ }, a_BlockMeta);
// ONLY recalculate lighting if it's necessary! // ONLY recalculate lighting if it's necessary!
if ( if (
@ -2471,31 +2471,22 @@ bool cChunk::GetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_
BLOCKTYPE cChunk::GetBlock(int a_RelX, int a_RelY, int a_RelZ) const void cChunk::GetBlockTypeMeta(Vector3i a_RelPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
{ {
return m_ChunkData.GetBlock(a_RelX, a_RelY, a_RelZ); a_BlockType = GetBlock(a_RelPos);
a_BlockMeta = GetMeta(a_RelPos);
} }
void cChunk::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const void cChunk::GetBlockInfo(Vector3i a_RelPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight)
{ {
a_BlockType = GetBlock(a_RelX, a_RelY, a_RelZ); a_BlockType = GetBlock(a_RelPos);
a_BlockMeta = m_ChunkData.GetMeta(a_RelX, a_RelY, a_RelZ); a_Meta = m_ChunkData.GetMeta(a_RelPos);
} a_SkyLight = m_ChunkData.GetSkyLight(a_RelPos);
a_BlockLight = m_ChunkData.GetBlockLight(a_RelPos);
void cChunk::GetBlockInfo(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight)
{
a_BlockType = GetBlock(a_RelX, a_RelY, a_RelZ);
a_Meta = m_ChunkData.GetMeta(a_RelX, a_RelY, a_RelZ);
a_SkyLight = m_ChunkData.GetSkyLight(a_RelX, a_RelY, a_RelZ);
a_BlockLight = m_ChunkData.GetBlockLight(a_RelX, a_RelY, a_RelZ);
} }

65
src/Chunk.h
View File

@ -154,7 +154,7 @@ public:
void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true); void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true);
// SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense // SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense
void SetBlock( const Vector3i & a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) { SetBlock( a_RelBlockPos.x, a_RelBlockPos.y, a_RelBlockPos.z, a_BlockType, a_BlockMeta); } void SetBlock(Vector3i a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) { SetBlock( a_RelBlockPos.x, a_RelBlockPos.y, a_RelBlockPos.z, a_BlockType, a_BlockMeta); }
/** Queues block for ticking (m_ToTickQueue) */ /** Queues block for ticking (m_ToTickQueue) */
void QueueTickBlock(int a_RelX, int a_RelY, int a_RelZ); void QueueTickBlock(int a_RelX, int a_RelY, int a_RelZ);
@ -163,10 +163,25 @@ public:
void QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ); void QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ);
void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true); // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc. void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true); // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc.
BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const; void FastSetBlock(Vector3i a_RelPos, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true)
BLOCKTYPE GetBlock(const Vector3i & a_RelCoords) const { return GetBlock(a_RelCoords.x, a_RelCoords.y, a_RelCoords.z); } {
void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const; FastSetBlock(a_RelPos.x, a_RelPos.y, a_RelPos.z, a_BlockType, a_BlockMeta, a_SendToClients);
void GetBlockInfo (int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight); }
BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const { return m_ChunkData.GetBlock({ a_RelX, a_RelY, a_RelZ }); }
BLOCKTYPE GetBlock(Vector3i a_RelCoords) const { return m_ChunkData.GetBlock(a_RelCoords); }
void GetBlockTypeMeta(Vector3i a_RelPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
{
GetBlockTypeMeta({ a_RelX, a_RelY, a_RelZ }, a_BlockType, a_BlockMeta);
}
void GetBlockInfo(Vector3i a_RelPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);
void GetBlockInfo(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight)
{
GetBlockInfo({ a_RelX, a_RelY, a_RelZ }, a_BlockType, a_Meta, a_SkyLight, a_BlockLight);
}
/** Convert absolute coordinates into relative coordinates. /** Convert absolute coordinates into relative coordinates.
Returns false on failure to obtain a valid chunk. Returns true otherwise. Returns false on failure to obtain a valid chunk. Returns true otherwise.
@ -392,39 +407,49 @@ public:
inline NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const inline NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
{ {
return m_ChunkData.GetMeta(a_RelX, a_RelY, a_RelZ); return m_ChunkData.GetMeta({ a_RelX, a_RelY, a_RelZ });
}
NIBBLETYPE GetMeta(Vector3i a_RelPos) const { return m_ChunkData.GetMeta(a_RelPos); }
void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true)
{
SetMeta({ a_RelX, a_RelY, a_RelZ }, a_Meta, a_ShouldMarkDirty, a_ShouldInformClients);
} }
/** Set a meta value, with the option of not informing the client and / or not marking dirty. /** Set a meta value, with the option of not informing the client and / or not marking dirty.
Used for setting metas that are of little value for saving to disk and / or for sending to the client, Used for setting metas that are of little value for saving to disk and / or for sending to the client,
such as leaf decay flags. */ such as leaf decay flags. */
inline void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true) inline void SetMeta(Vector3i a_RelPos, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true)
{ {
bool hasChanged = m_ChunkData.SetMeta(a_RelX, a_RelY, a_RelZ, a_Meta); bool hasChanged = m_ChunkData.SetMeta(a_RelPos, a_Meta);
if (hasChanged) if (hasChanged)
{
if (a_ShouldMarkDirty)
{ {
if (a_ShouldMarkDirty) MarkDirty();
{
MarkDirty();
}
if (a_ShouldInformClients)
{
m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, GetBlock(a_RelX, a_RelY, a_RelZ), a_Meta));
}
} }
if (a_ShouldInformClients)
{
m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelPos.x, a_RelPos.y, a_RelPos.z, GetBlock(a_RelPos), a_Meta));
}
}
} }
/** Light alterations based on time */ /** Light alterations based on time */
NIBBLETYPE GetTimeAlteredLight(NIBBLETYPE a_Skylight) const; NIBBLETYPE GetTimeAlteredLight(NIBBLETYPE a_Skylight) const;
/** Get the level of artificial light illuminating the block (0 - 15) */ /** Get the level of artificial light illuminating the block (0 - 15) */
inline NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const {return m_ChunkData.GetBlockLight(a_RelX, a_RelY, a_RelZ); } inline NIBBLETYPE GetBlockLight(Vector3i a_RelPos) const { return m_ChunkData.GetBlockLight(a_RelPos); }
inline NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const { return m_ChunkData.GetBlockLight({ a_RelX, a_RelY, a_RelZ }); }
/** Get the level of sky light illuminating the block (0 - 15) independent of daytime. */ /** Get the level of sky light illuminating the block (0 - 15) independent of daytime. */
inline NIBBLETYPE GetSkyLight (int a_RelX, int a_RelY, int a_RelZ) const {return m_ChunkData.GetSkyLight(a_RelX, a_RelY, a_RelZ); } inline NIBBLETYPE GetSkyLight(Vector3i a_RelPos) const { return m_ChunkData.GetSkyLight(a_RelPos); }
inline NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const { return m_ChunkData.GetSkyLight({ a_RelX, a_RelY, a_RelZ }); }
/** Get the level of sky light illuminating the block (0 - 15), taking daytime into a account. */ /** Get the level of sky light illuminating the block (0 - 15), taking daytime into a account. */
inline NIBBLETYPE GetSkyLightAltered (int a_RelX, int a_RelY, int a_RelZ) const {return GetTimeAlteredLight(m_ChunkData.GetSkyLight(a_RelX, a_RelY, a_RelZ)); } inline NIBBLETYPE GetSkyLightAltered(Vector3i a_RelPos) const { return GetTimeAlteredLight(m_ChunkData.GetSkyLight(a_RelPos)); }
inline NIBBLETYPE GetSkyLightAltered(int a_RelX, int a_RelY, int a_RelZ) const { return GetSkyLightAltered({ a_RelX, a_RelY, a_RelZ }); }
/** Same as GetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */ /** Same as GetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success */
bool UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const; bool UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;

140
src/ChunkData.cpp
View File

@ -10,18 +10,41 @@
/** Returns true if all a_Array's elements between [0] and [a_NumElements - 1] are equal to a_Value. */ namespace
template <typename T> inline bool IsAllValue(const T * a_Array, size_t a_NumElements, T a_Value)
{ {
for (size_t i = 0; i < a_NumElements; i++) /** Returns true if all a_Array's elements between [0] and [a_NumElements - 1] are equal to a_Value. */
template <typename T>
bool IsAllValue(const T * a_Array, size_t a_NumElements, T a_Value)
{ {
if (a_Array[i] != a_Value) for (size_t i = 0; i < a_NumElements; i++)
{ {
return false; if (a_Array[i] != a_Value)
{
return false;
}
} }
return true;
} }
return true;
}
struct sSectionIndices
{
int Section = 0; // Index into m_Sections
int Index = 0; // Index into a single sChunkSection
};
sSectionIndices IndicesFromRelPos(Vector3i a_RelPos)
{
ASSERT(cChunkDef::IsValidRelPos(a_RelPos));
sSectionIndices Ret;
Ret.Section = a_RelPos.y / cChunkData::SectionHeight;
Ret.Index = cChunkDef::MakeIndexNoCheck(a_RelPos.x, a_RelPos.y % cChunkData::SectionHeight, a_RelPos.z);
return Ret;
}
} // namespace (anonymous)
@ -110,21 +133,16 @@ void cChunkData::Assign(cChunkData && a_Other)
BLOCKTYPE cChunkData::GetBlock(int a_X, int a_Y, int a_Z) const BLOCKTYPE cChunkData::GetBlock(Vector3i a_RelPos) const
{ {
if ( if (!cChunkDef::IsValidRelPos(a_RelPos))
(a_X < 0) || (a_X >= cChunkDef::Width) ||
(a_Y < 0) || (a_Y >= cChunkDef::Height) ||
(a_Z < 0) || (a_Z >= cChunkDef::Width)
)
{ {
return E_BLOCK_AIR; // Coordinates are outside outside the world, so this must be an air block return E_BLOCK_AIR; // Coordinates are outside outside the world, so this must be an air block
} }
int Section = a_Y / SectionHeight; auto Idxs = IndicesFromRelPos(a_RelPos);
if (m_Sections[Section] != nullptr) if (m_Sections[Idxs.Section] != nullptr)
{ {
int Index = cChunkDef::MakeIndexNoCheck(a_X, static_cast<int>(static_cast<UInt32>(a_Y) - (static_cast<UInt32>(Section) * SectionHeight)), a_Z); return m_Sections[Idxs.Section]->m_BlockTypes[Idxs.Index];
return m_Sections[Section]->m_BlockTypes[Index];
} }
else else
{ {
@ -136,53 +154,44 @@ BLOCKTYPE cChunkData::GetBlock(int a_X, int a_Y, int a_Z) const
void cChunkData::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block) void cChunkData::SetBlock(Vector3i a_RelPos, BLOCKTYPE a_Block)
{ {
if ( if (!cChunkDef::IsValidRelPos(a_RelPos))
(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!"); ASSERT(!"cChunkData::SetMeta(): index out of range!");
return; return;
} }
int Section = static_cast<int>(static_cast<UInt32>(a_RelY) / SectionHeight); auto Idxs = IndicesFromRelPos(a_RelPos);
if (m_Sections[Section] == nullptr) if (m_Sections[Idxs.Section] == nullptr)
{ {
if (a_Block == 0x00) if (a_Block == 0x00)
{ {
return; return;
} }
m_Sections[Section] = Allocate(); m_Sections[Idxs.Section] = Allocate();
if (m_Sections[Section] == nullptr) if (m_Sections[Idxs.Section] == nullptr)
{ {
ASSERT(!"Failed to allocate a new section in Chunkbuffer"); ASSERT(!"Failed to allocate a new section in Chunkbuffer");
return; return;
} }
ZeroSection(m_Sections[Section]); ZeroSection(m_Sections[Idxs.Section]);
} }
int Index = cChunkDef::MakeIndexNoCheck(a_RelX, static_cast<int>(static_cast<UInt32>(a_RelY) - (static_cast<UInt32>(Section) * SectionHeight)), a_RelZ); m_Sections[Idxs.Section]->m_BlockTypes[Idxs.Index] = a_Block;
m_Sections[Section]->m_BlockTypes[Index] = a_Block;
} }
NIBBLETYPE cChunkData::GetMeta(int a_RelX, int a_RelY, int a_RelZ) const NIBBLETYPE cChunkData::GetMeta(Vector3i a_RelPos) const
{ {
if ( if (cChunkDef::IsValidRelPos(a_RelPos))
(a_RelX < cChunkDef::Width) && (a_RelX > -1) &&
(a_RelY < cChunkDef::Height) && (a_RelY > -1) &&
(a_RelZ < cChunkDef::Width) && (a_RelZ > -1))
{ {
int Section = static_cast<int>(static_cast<UInt32>(a_RelY) / SectionHeight); auto Idxs = IndicesFromRelPos(a_RelPos);
if (m_Sections[Section] != nullptr) if (m_Sections[Idxs.Section] != nullptr)
{ {
int Index = cChunkDef::MakeIndexNoCheck(a_RelX, static_cast<int>(static_cast<UInt32>(a_RelY) - (static_cast<UInt32>(Section) * SectionHeight)), a_RelZ); return (m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4)) & 0x0f;
return (m_Sections[Section]->m_BlockMetas[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
} }
else else
{ {
@ -197,38 +206,33 @@ NIBBLETYPE cChunkData::GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
bool cChunkData::SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble) bool cChunkData::SetMeta(Vector3i a_RelPos, NIBBLETYPE a_Nibble)
{ {
if ( if (!cChunkDef::IsValidRelPos(a_RelPos))
(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!"); ASSERT(!"cChunkData::SetMeta(): index out of range!");
return false; return false;
} }
int Section = static_cast<int>(static_cast<UInt32>(a_RelY) / SectionHeight); auto Idxs = IndicesFromRelPos(a_RelPos);
if (m_Sections[Section] == nullptr) if (m_Sections[Idxs.Section] == nullptr)
{ {
if ((a_Nibble & 0xf) == 0x00) if ((a_Nibble & 0xf) == 0x00)
{ {
return false; return false;
} }
m_Sections[Section] = Allocate(); m_Sections[Idxs.Section] = Allocate();
if (m_Sections[Section] == nullptr) if (m_Sections[Idxs.Section] == nullptr)
{ {
ASSERT(!"Failed to allocate a new section in Chunkbuffer"); ASSERT(!"Failed to allocate a new section in Chunkbuffer");
return false; return false;
} }
ZeroSection(m_Sections[Section]); ZeroSection(m_Sections[Idxs.Section]);
} }
int Index = cChunkDef::MakeIndexNoCheck(a_RelX, static_cast<int>(static_cast<UInt32>(a_RelY) - (static_cast<UInt32>(Section) * SectionHeight)), a_RelZ); NIBBLETYPE oldval = m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4) & 0xf;
NIBBLETYPE oldval = m_Sections[Section]->m_BlockMetas[Index / 2] >> ((Index & 1) * 4) & 0xf; m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] = static_cast<NIBBLETYPE>(
m_Sections[Section]->m_BlockMetas[Index / 2] = static_cast<NIBBLETYPE>( (m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] & (0xf0 >> ((Idxs.Index & 1) * 4))) | // The untouched nibble
(m_Sections[Section]->m_BlockMetas[Index / 2] & (0xf0 >> ((Index & 1) * 4))) | // The untouched nibble ((a_Nibble & 0x0f) << ((Idxs.Index & 1) * 4)) // The nibble being set
((a_Nibble & 0x0f) << ((Index & 1) * 4)) // The nibble being set
); );
return oldval != a_Nibble; return oldval != a_Nibble;
} }
@ -237,19 +241,14 @@ bool cChunkData::SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble
NIBBLETYPE cChunkData::GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const NIBBLETYPE cChunkData::GetBlockLight(Vector3i a_RelPos) const
{ {
if ( if (cChunkDef::IsValidRelPos(a_RelPos))
(a_RelX < cChunkDef::Width) && (a_RelX > -1) &&
(a_RelY < cChunkDef::Height) && (a_RelY > -1) &&
(a_RelZ < cChunkDef::Width) && (a_RelZ > -1)
)
{ {
int Section = static_cast<int>(static_cast<UInt32>(a_RelY) / SectionHeight); auto Idxs = IndicesFromRelPos(a_RelPos);
if (m_Sections[Section] != nullptr) if (m_Sections[Idxs.Section] != nullptr)
{ {
int Index = cChunkDef::MakeIndexNoCheck(a_RelX, static_cast<int>(static_cast<UInt32>(a_RelY) - (static_cast<UInt32>(Section) * SectionHeight)), a_RelZ); return (m_Sections[Idxs.Section]->m_BlockLight[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4)) & 0x0f;
return (m_Sections[Section]->m_BlockLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
} }
else else
{ {
@ -264,15 +263,14 @@ NIBBLETYPE cChunkData::GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const
NIBBLETYPE cChunkData::GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const NIBBLETYPE cChunkData::GetSkyLight(Vector3i a_RelPos) const
{ {
if ((a_RelX < cChunkDef::Width) && (a_RelX > -1) && (a_RelY < cChunkDef::Height) && (a_RelY > -1) && (a_RelZ < cChunkDef::Width) && (a_RelZ > -1)) if (cChunkDef::IsValidRelPos(a_RelPos))
{ {
int Section = static_cast<int>(static_cast<UInt32>(a_RelY) / SectionHeight); auto Idxs = IndicesFromRelPos(a_RelPos);
if (m_Sections[Section] != nullptr) if (m_Sections[Idxs.Section] != nullptr)
{ {
int Index = cChunkDef::MakeIndexNoCheck(a_RelX, static_cast<int>(static_cast<UInt32>(a_RelY) - (static_cast<UInt32>(Section) * SectionHeight)), a_RelZ); return (m_Sections[Idxs.Section]->m_BlockSkyLight[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4)) & 0x0f;
return (m_Sections[Section]->m_BlockSkyLight[Index / 2] >> ((Index & 1) * 4)) & 0x0f;
} }
else else
{ {

12
src/ChunkData.h
View File

@ -48,15 +48,15 @@ public:
/** Move assign from another cChunkData */ /** Move assign from another cChunkData */
void Assign(cChunkData && a_Other); void Assign(cChunkData && a_Other);
BLOCKTYPE GetBlock(int a_X, int a_Y, int a_Z) const; BLOCKTYPE GetBlock(Vector3i a_RelPos) const;
void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block); void SetBlock(Vector3i a_RelPos, BLOCKTYPE a_Block);
NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const; NIBBLETYPE GetMeta(Vector3i a_RelPos) const;
bool SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Nibble); bool SetMeta(Vector3i a_RelPos, NIBBLETYPE a_Nibble);
NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const; NIBBLETYPE GetBlockLight(Vector3i a_RelPos) const;
NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const; NIBBLETYPE GetSkyLight(Vector3i a_RelPos) const;
/** Return a pointer to the chunk section or nullptr if all air */ /** Return a pointer to the chunk section or nullptr if all air */
const sChunkSection * GetSection(size_t a_SectionNum) const; const sChunkSection * GetSection(size_t a_SectionNum) const;

10
src/ChunkDef.h
View File

@ -144,6 +144,16 @@ public:
return ((a_Width >= 0) && (a_Width < Width)); return ((a_Width >= 0) && (a_Width < Width));
} }
/** Validates a chunk relative coordinate. Returns false if the coordiante is out of bounds for a chunk. */
inline static bool IsValidRelPos(Vector3i a_RelPos)
{
return (
IsValidWidth(a_RelPos.x) &&
IsValidHeight(a_RelPos.y) &&
IsValidWidth(a_RelPos.z)
);
}
/** Converts absolute block coords to chunk coords: */ /** Converts absolute block coords to chunk coords: */
inline static void BlockToChunk(int a_X, int a_Z, int & a_ChunkX, int & a_ChunkZ) inline static void BlockToChunk(int a_X, int a_Z, int & a_ChunkX, int & a_ChunkZ)
{ {

54
tests/ChunkData/ArraytoCoord.cpp
View File

@ -10,19 +10,19 @@ int main(int argc, char** argv)
class cMockAllocationPool class cMockAllocationPool
: public cAllocationPool<cChunkData::sChunkSection> : public cAllocationPool<cChunkData::sChunkSection>
{ {
virtual cChunkData::sChunkSection * Allocate() virtual cChunkData::sChunkSection * Allocate()
{ {
return new cChunkData::sChunkSection(); return new cChunkData::sChunkSection();
} }
virtual void Free(cChunkData::sChunkSection * a_Ptr) virtual void Free(cChunkData::sChunkSection * a_Ptr)
{ {
delete a_Ptr; delete a_Ptr;
} }
} Pool; } Pool;
{ {
// Test first segment // Test first segment
cChunkData buffer(Pool); cChunkData buffer(Pool);
@ -30,25 +30,25 @@ int main(int argc, char** argv)
memset(SrcBlockBuffer, 0x00, sizeof(SrcBlockBuffer)); memset(SrcBlockBuffer, 0x00, sizeof(SrcBlockBuffer));
SrcBlockBuffer[7 + (4 * 16) + (5 * 16 * 16)] = 0xcd; SrcBlockBuffer[7 + (4 * 16) + (5 * 16 * 16)] = 0xcd;
buffer.SetBlockTypes(SrcBlockBuffer); buffer.SetBlockTypes(SrcBlockBuffer);
testassert(buffer.GetBlock(7, 5, 4) == 0xcd); testassert(buffer.GetBlock({ 7, 5, 4 }) == 0xcd);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
SrcNibbleBuffer[(6 + (1 * 16) + (2 * 16 * 16)) / 2] = 0xe; SrcNibbleBuffer[(6 + (1 * 16) + (2 * 16 * 16)) / 2] = 0xe;
buffer.SetMetas(SrcNibbleBuffer); buffer.SetMetas(SrcNibbleBuffer);
testassert(buffer.GetMeta(6, 2, 1) == 0xe); testassert(buffer.GetMeta({ 6, 2, 1 }) == 0xe);
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
SrcNibbleBuffer[(6 + (1 * 16) + (2 * 16 * 16)) / 2] = 0xe; SrcNibbleBuffer[(6 + (1 * 16) + (2 * 16 * 16)) / 2] = 0xe;
buffer.SetBlockLight(SrcNibbleBuffer); buffer.SetBlockLight(SrcNibbleBuffer);
testassert(buffer.GetBlockLight(6, 2, 1) == 0xe); testassert(buffer.GetBlockLight({ 6, 2, 1 }) == 0xe);
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
SrcNibbleBuffer[(6 + (1 * 16) + (2 * 16 * 16)) / 2] = 0xe; SrcNibbleBuffer[(6 + (1 * 16) + (2 * 16 * 16)) / 2] = 0xe;
buffer.SetSkyLight(SrcNibbleBuffer); buffer.SetSkyLight(SrcNibbleBuffer);
testassert(buffer.GetSkyLight(6, 2, 1) == 0xe); testassert(buffer.GetSkyLight({ 6, 2, 1 }) == 0xe);
} }
{ {
// test following segment // test following segment
cChunkData buffer(Pool); cChunkData buffer(Pool);
@ -57,25 +57,25 @@ int main(int argc, char** argv)
memset(SrcBlockBuffer, 0x00, sizeof(SrcBlockBuffer)); memset(SrcBlockBuffer, 0x00, sizeof(SrcBlockBuffer));
SrcBlockBuffer[7 + (4 * 16) + (24 * 16 * 16)] = 0xcd; SrcBlockBuffer[7 + (4 * 16) + (24 * 16 * 16)] = 0xcd;
buffer.SetBlockTypes(SrcBlockBuffer); buffer.SetBlockTypes(SrcBlockBuffer);
testassert(buffer.GetBlock(7, 24, 4) == 0xcd); testassert(buffer.GetBlock({ 7, 24, 4 }) == 0xcd);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
SrcNibbleBuffer[(6 + (1 * 16) + (24 * 16 * 16)) / 2] = 0xe; SrcNibbleBuffer[(6 + (1 * 16) + (24 * 16 * 16)) / 2] = 0xe;
buffer.SetMetas(SrcNibbleBuffer); buffer.SetMetas(SrcNibbleBuffer);
testassert(buffer.GetMeta(6, 24, 1) == 0xe); testassert(buffer.GetMeta({ 6, 24, 1 }) == 0xe);
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
SrcNibbleBuffer[(6 + 1 * 16 + 24 * 16 * 16) / 2] = 0xe; SrcNibbleBuffer[(6 + 1 * 16 + 24 * 16 * 16) / 2] = 0xe;
buffer.SetBlockLight(SrcNibbleBuffer); buffer.SetBlockLight(SrcNibbleBuffer);
testassert(buffer.GetBlockLight(6, 24, 1) == 0xe); testassert(buffer.GetBlockLight({ 6, 24, 1 }) == 0xe);
memset(SrcNibbleBuffer, 0xff, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0xff, sizeof(SrcNibbleBuffer));
SrcNibbleBuffer[(6 + (1 * 16) + (24 * 16 * 16)) / 2] = 0xe; SrcNibbleBuffer[(6 + (1 * 16) + (24 * 16 * 16)) / 2] = 0xe;
buffer.SetSkyLight(SrcNibbleBuffer); buffer.SetSkyLight(SrcNibbleBuffer);
testassert(buffer.GetSkyLight(6, 24, 1) == 0xe); testassert(buffer.GetSkyLight({ 6, 24, 1 }) == 0xe);
} }
{ {
// test zeros // test zeros
cChunkData buffer(Pool); cChunkData buffer(Pool);
@ -83,22 +83,22 @@ int main(int argc, char** argv)
BLOCKTYPE SrcBlockBuffer[16 * 16 * 256]; BLOCKTYPE SrcBlockBuffer[16 * 16 * 256];
memset(SrcBlockBuffer, 0x00, sizeof(SrcBlockBuffer)); memset(SrcBlockBuffer, 0x00, sizeof(SrcBlockBuffer));
buffer.SetBlockTypes(SrcBlockBuffer); buffer.SetBlockTypes(SrcBlockBuffer);
testassert(buffer.GetBlock(7, 24, 4) == 0x00); testassert(buffer.GetBlock({ 7, 24, 4 }) == 0x00);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
buffer.SetMetas(SrcNibbleBuffer); buffer.SetMetas(SrcNibbleBuffer);
testassert(buffer.GetMeta(6, 24, 1) == 0x0); testassert(buffer.GetMeta({ 6, 24, 1 }) == 0x0);
memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0x00, sizeof(SrcNibbleBuffer));
buffer.SetBlockLight(SrcNibbleBuffer); buffer.SetBlockLight(SrcNibbleBuffer);
testassert(buffer.GetBlockLight(6, 24, 1) == 0x0); testassert(buffer.GetBlockLight({ 6, 24, 1 }) == 0x0);
memset(SrcNibbleBuffer, 0xff, sizeof(SrcNibbleBuffer)); memset(SrcNibbleBuffer, 0xff, sizeof(SrcNibbleBuffer));
buffer.SetSkyLight(SrcNibbleBuffer); buffer.SetSkyLight(SrcNibbleBuffer);
testassert(buffer.GetSkyLight(6, 24, 1) == 0xf); testassert(buffer.GetSkyLight({ 6, 24, 1 }) == 0xf);
} }
// All tests passed: // All tests passed:
return 0; return 0;
} }

84
tests/ChunkData/Coordinates.cpp
View File

@ -25,98 +25,98 @@ int main(int argc, char** argv)
cChunkData buffer(Pool); cChunkData buffer(Pool);
// Empty chunks // Empty chunks
buffer.SetBlock(0, 0, 0, 0xAB); buffer.SetBlock({ 0, 0, 0 }, 0xAB);
testassert(buffer.GetBlock(0, 0, 0) == 0xAB); testassert(buffer.GetBlock({ 0, 0, 0 }) == 0xAB);
buffer.SetMeta(0, 16, 0, 0xC); buffer.SetMeta({ 0, 16, 0 }, 0xC);
testassert(buffer.GetMeta(0, 16, 0) == 0xC); testassert(buffer.GetMeta({ 0, 16, 0 }) == 0xC);
// loaded but not written segments // loaded but not written segments
testassert(buffer.GetBlock(1, 0, 0) == 0x0); testassert(buffer.GetBlock({ 1, 0, 0 }) == 0x0);
testassert(buffer.GetMeta(1, 16, 0) == 0x0); testassert(buffer.GetMeta({ 1, 16, 0 }) == 0x0);
// Notloaded segments // Notloaded segments
testassert(buffer.GetBlock(0, 32, 0) == 0x0); testassert(buffer.GetBlock({ 0, 32, 0 }) == 0x0);
testassert(buffer.GetMeta(0, 48, 0) == 0x0); testassert(buffer.GetMeta({ 0, 48, 0 }) == 0x0);
// Out of range SetBlock // Out of range SetBlock
CheckAsserts( CheckAsserts(
buffer.SetBlock(-1, 0, 0, 0); buffer.SetBlock({ -1, 0, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetBlock(0, -1, 0, 0); buffer.SetBlock({ 0, -1, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetBlock(0, 0, -1, 0); buffer.SetBlock({ 0, 0, -1 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetBlock(256, 0, 0, 0); buffer.SetBlock({ 256, 0, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetBlock(0, 256, 0, 0); buffer.SetBlock({ 0, 256, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetBlock(0, 0, 256, 0); buffer.SetBlock({ 0, 0, 256 }, 0);
); );
// Out of range SetMeta // Out of range SetMeta
CheckAsserts( CheckAsserts(
buffer.SetMeta(-1, 0, 0, 0); buffer.SetMeta({ -1, 0, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetMeta(0, -1, 0, 0); buffer.SetMeta({ 0, -1, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetMeta(0, 0, -1, 0); buffer.SetMeta({ 0, 0, -1 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetMeta(256, 0, 0, 0); buffer.SetMeta({ 256, 0, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetMeta(0, 256, 0, 0); buffer.SetMeta({ 0, 256, 0 }, 0);
); );
CheckAsserts( CheckAsserts(
buffer.SetMeta(0, 0, 256, 0); buffer.SetMeta({ 0, 0, 256 }, 0);
); );
// Reading out of range blocks should return air // Reading out of range blocks should return air
testassert(buffer.GetBlock(-1, 0, 0) == 0); testassert(buffer.GetBlock({ -1, 0, 0 }) == 0);
testassert(buffer.GetBlock(0, -1, 0) == 0); testassert(buffer.GetBlock({ 0, -1, 0 }) == 0);
testassert(buffer.GetBlock(0, 0, -1) == 0); testassert(buffer.GetBlock({ 0, 0, -1 }) == 0);
testassert(buffer.GetBlock(256, 0, 0) == 0); testassert(buffer.GetBlock({ 256, 0, 0 }) == 0);
testassert(buffer.GetBlock(0, 256, 0) == 0); testassert(buffer.GetBlock({ 0, 256, 0 }) == 0);
testassert(buffer.GetBlock(0, 0, 256) == 0); testassert(buffer.GetBlock({ 0, 0, 256 }) == 0);
// Reading out of range metas should return 0 // Reading out of range metas should return 0
testassert(buffer.GetMeta(-1, 0, 0) == 0); testassert(buffer.GetMeta({ -1, 0, 0 }) == 0);
testassert(buffer.GetMeta(0, -1, 0) == 0); testassert(buffer.GetMeta({ 0, -1, 0 }) == 0);
testassert(buffer.GetMeta(0, 0, -1) == 0); testassert(buffer.GetMeta({ 0, 0, -1 }) == 0);
testassert(buffer.GetMeta(256, 0, 0) == 0); testassert(buffer.GetMeta({ 256, 0, 0 }) == 0);
testassert(buffer.GetMeta(0, 256, 0) == 0); testassert(buffer.GetMeta({ 0, 256, 0 }) == 0);
testassert(buffer.GetMeta(0, 0, 256) == 0); testassert(buffer.GetMeta({ 0, 0, 256 }) == 0);
} }
{ {
cChunkData buffer(Pool); cChunkData buffer(Pool);
// Zero's // Zero's
buffer.SetBlock(0, 0, 0, 0x0); buffer.SetBlock({ 0, 0, 0 }, 0x0);
buffer.SetBlock(0, 0, 1, 0xab); buffer.SetBlock({ 0, 0, 1 }, 0xab);
testassert(buffer.GetBlock(0, 0, 0) == 0x0); testassert(buffer.GetBlock({ 0, 0, 0 }) == 0x0);
testassert(buffer.GetBlock(0, 0, 1) == 0xab); testassert(buffer.GetBlock({ 0, 0, 1 }) == 0xab);
buffer.SetMeta(0, 16, 0, 0x0); buffer.SetMeta({ 0, 16, 0 }, 0x0);
buffer.SetMeta(0, 16, 1, 0xc); buffer.SetMeta({ 0, 16, 1 }, 0xc);
testassert(buffer.GetMeta(0, 16, 0) == 0x0); testassert(buffer.GetMeta({ 0, 16, 0 }) == 0x0);
testassert(buffer.GetMeta(0, 16, 1) == 0xc); testassert(buffer.GetMeta({ 0, 16, 1 }) == 0xc);
} }
{ {
// Operator = // Operator =
cChunkData buffer(Pool); cChunkData buffer(Pool);
buffer.SetBlock(0, 0, 0, 0x42); buffer.SetBlock({ 0, 0, 0 }, 0x42);
cChunkData copy(Pool); cChunkData copy(Pool);
copy = std::move(buffer); copy = std::move(buffer);
testassert(copy.GetBlock(0, 0, 0) == 0x42); testassert(copy.GetBlock({ 0, 0, 0 }) == 0x42);
} }
return 0; return 0;

58
tests/ChunkData/Copies.cpp
View File

@ -10,12 +10,12 @@ int main(int argc, char** argv)
class cMockAllocationPool class cMockAllocationPool
: public cAllocationPool<cChunkData::sChunkSection> : public cAllocationPool<cChunkData::sChunkSection>
{ {
virtual cChunkData::sChunkSection * Allocate() virtual cChunkData::sChunkSection * Allocate()
{ {
return new cChunkData::sChunkSection(); return new cChunkData::sChunkSection();
} }
virtual void Free(cChunkData::sChunkSection * a_Ptr) virtual void Free(cChunkData::sChunkSection * a_Ptr)
{ {
delete a_Ptr; delete a_Ptr;
@ -23,15 +23,15 @@ int main(int argc, char** argv)
} Pool; } Pool;
{ {
cChunkData buffer(Pool); cChunkData buffer(Pool);
buffer.SetBlock(3, 1, 4, 0xDE); buffer.SetBlock({ 3, 1, 4 }, 0xDE);
buffer.SetMeta(3, 1, 4, 0xA); buffer.SetMeta({ 3, 1, 4 }, 0xA);
cChunkData copy(Pool); cChunkData copy(Pool);
copy.Assign(buffer); copy.Assign(buffer);
testassert(copy.GetBlock(3, 1, 4) == 0xDE); testassert(copy.GetBlock({ 3, 1, 4 }) == 0xDE);
testassert(copy.GetMeta(3, 1, 4) == 0xA); testassert(copy.GetMeta({ 3, 1, 4 }) == 0xA);
BLOCKTYPE SrcBlockBuffer[16 * 16 * 256]; BLOCKTYPE SrcBlockBuffer[16 * 16 * 256];
for (int i = 0; i < 16 * 16 * 256; i += 4) for (int i = 0; i < 16 * 16 * 256; i += 4)
{ {
@ -40,21 +40,21 @@ int main(int argc, char** argv)
SrcBlockBuffer[i + 2] = 0xbe; SrcBlockBuffer[i + 2] = 0xbe;
SrcBlockBuffer[i + 3] = 0xef; SrcBlockBuffer[i + 3] = 0xef;
} }
buffer.SetBlockTypes(SrcBlockBuffer); buffer.SetBlockTypes(SrcBlockBuffer);
BLOCKTYPE DstBlockBuffer[16 * 16 * 256]; BLOCKTYPE DstBlockBuffer[16 * 16 * 256];
buffer.CopyBlockTypes(DstBlockBuffer); buffer.CopyBlockTypes(DstBlockBuffer);
testassert(memcmp(SrcBlockBuffer, DstBlockBuffer, (16 * 16 * 256) - 1) == 0); testassert(memcmp(SrcBlockBuffer, DstBlockBuffer, (16 * 16 * 256) - 1) == 0);
memset(SrcBlockBuffer, 0x00, 16 * 16 * 256); memset(SrcBlockBuffer, 0x00, 16 * 16 * 256);
buffer.SetBlockTypes(SrcBlockBuffer); buffer.SetBlockTypes(SrcBlockBuffer);
buffer.CopyBlockTypes(DstBlockBuffer); buffer.CopyBlockTypes(DstBlockBuffer);
testassert(memcmp(SrcBlockBuffer, DstBlockBuffer, (16 * 16 * 256) - 1) == 0); testassert(memcmp(SrcBlockBuffer, DstBlockBuffer, (16 * 16 * 256) - 1) == 0);
} }
{ {
cChunkData buffer(Pool); cChunkData buffer(Pool);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
for (int i = 0; i < 16 * 16 * 256 / 2; i += 4) for (int i = 0; i < 16 * 16 * 256 / 2; i += 4)
{ {
@ -63,21 +63,21 @@ int main(int argc, char** argv)
SrcNibbleBuffer[i + 2] = 0xbe; SrcNibbleBuffer[i + 2] = 0xbe;
SrcNibbleBuffer[i + 3] = 0xef; SrcNibbleBuffer[i + 3] = 0xef;
} }
buffer.SetMetas(SrcNibbleBuffer); buffer.SetMetas(SrcNibbleBuffer);
NIBBLETYPE DstNibbleBuffer[16 * 16 * 256/ 2]; NIBBLETYPE DstNibbleBuffer[16 * 16 * 256/ 2];
buffer.CopyMetas(DstNibbleBuffer); buffer.CopyMetas(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 /2); memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 /2);
buffer.SetMetas(SrcNibbleBuffer); buffer.SetMetas(SrcNibbleBuffer);
buffer.CopyMetas(DstNibbleBuffer); buffer.CopyMetas(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
} }
{ {
cChunkData buffer(Pool); cChunkData buffer(Pool);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
for (int i = 0; i < 16 * 16 * 256 / 2; i += 4) for (int i = 0; i < 16 * 16 * 256 / 2; i += 4)
{ {
@ -86,21 +86,21 @@ int main(int argc, char** argv)
SrcNibbleBuffer[i + 2] = 0xbe; SrcNibbleBuffer[i + 2] = 0xbe;
SrcNibbleBuffer[i + 3] = 0xef; SrcNibbleBuffer[i + 3] = 0xef;
} }
buffer.SetBlockLight(SrcNibbleBuffer); buffer.SetBlockLight(SrcNibbleBuffer);
NIBBLETYPE DstNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE DstNibbleBuffer[16 * 16 * 256 / 2];
buffer.CopyBlockLight(DstNibbleBuffer); buffer.CopyBlockLight(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 /2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 /2) - 1) == 0);
memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 /2); memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 /2);
buffer.SetBlockLight(SrcNibbleBuffer); buffer.SetBlockLight(SrcNibbleBuffer);
buffer.CopyBlockLight(DstNibbleBuffer); buffer.CopyBlockLight(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 /2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 /2) - 1) == 0);
} }
{ {
cChunkData buffer(Pool); cChunkData buffer(Pool);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
for (int i = 0; i < 16 * 16 * 256 / 2; i += 4) for (int i = 0; i < 16 * 16 * 256 / 2; i += 4)
{ {
@ -109,42 +109,42 @@ int main(int argc, char** argv)
SrcNibbleBuffer[i + 2] = 0xbe; SrcNibbleBuffer[i + 2] = 0xbe;
SrcNibbleBuffer[i + 3] = 0xef; SrcNibbleBuffer[i + 3] = 0xef;
} }
buffer.SetSkyLight(SrcNibbleBuffer); buffer.SetSkyLight(SrcNibbleBuffer);
NIBBLETYPE DstNibbleBuffer[16 * 16 * 256/ 2]; NIBBLETYPE DstNibbleBuffer[16 * 16 * 256/ 2];
buffer.CopySkyLight(DstNibbleBuffer); buffer.CopySkyLight(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
memset(SrcNibbleBuffer, 0xFF, 16 * 16 * 256 / 2); memset(SrcNibbleBuffer, 0xFF, 16 * 16 * 256 / 2);
buffer.SetSkyLight(SrcNibbleBuffer); buffer.SetSkyLight(SrcNibbleBuffer);
buffer.CopySkyLight(DstNibbleBuffer); buffer.CopySkyLight(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
} }
{ {
cChunkData buffer(Pool); cChunkData buffer(Pool);
BLOCKTYPE SrcBlockBuffer[16 * 16 * 256]; BLOCKTYPE SrcBlockBuffer[16 * 16 * 256];
memset(SrcBlockBuffer, 0x00, 16 * 16 * 256); memset(SrcBlockBuffer, 0x00, 16 * 16 * 256);
BLOCKTYPE DstBlockBuffer[16 * 16 * 256]; BLOCKTYPE DstBlockBuffer[16 * 16 * 256];
buffer.CopyBlockTypes(DstBlockBuffer); buffer.CopyBlockTypes(DstBlockBuffer);
testassert(memcmp(SrcBlockBuffer, DstBlockBuffer, (16 * 16 * 256) - 1) == 0); testassert(memcmp(SrcBlockBuffer, DstBlockBuffer, (16 * 16 * 256) - 1) == 0);
NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE SrcNibbleBuffer[16 * 16 * 256 / 2];
memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 / 2); memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 / 2);
NIBBLETYPE DstNibbleBuffer[16 * 16 * 256 / 2]; NIBBLETYPE DstNibbleBuffer[16 * 16 * 256 / 2];
buffer.CopyMetas(DstNibbleBuffer); buffer.CopyMetas(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 / 2); memset(SrcNibbleBuffer, 0x00, 16 * 16 * 256 / 2);
buffer.CopyBlockLight(DstNibbleBuffer); buffer.CopyBlockLight(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
memset(SrcNibbleBuffer, 0xFF, 16 * 16 * 256 / 2); memset(SrcNibbleBuffer, 0xFF, 16 * 16 * 256 / 2);
buffer.CopySkyLight(DstNibbleBuffer); buffer.CopySkyLight(DstNibbleBuffer);
testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0); testassert(memcmp(SrcNibbleBuffer, DstNibbleBuffer, (16 * 16 * 256 / 2) - 1) == 0);
} }
// All tests successful: // All tests successful:
return 0; return 0;
} }