diff options
Diffstat (limited to '')
| -rw-r--r-- | src/ChunkData.cpp | 658 |
1 files changed, 81 insertions, 577 deletions
diff --git a/src/ChunkData.cpp b/src/ChunkData.cpp index a480c2c66..a820f043b 100644 --- a/src/ChunkData.cpp +++ b/src/ChunkData.cpp @@ -13,437 +13,121 @@ namespace { - /** 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) + struct SectionIndices { - for (size_t i = 0; i < a_NumElements; i++) - { - if (a_Array[i] != a_Value) - { - return false; - } - } - return true; - } - - - - - - struct sSectionIndices - { - int Section = 0; // Index into m_Sections - int Index = 0; // Index into a single sChunkSection + size_t Section = 0; // Index into m_Sections + size_t Index = 0; // Index into a single sChunkSection }; - sSectionIndices IndicesFromRelPos(Vector3i a_RelPos) + inline SectionIndices IndicesFromRelPos(const 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) - - - - - -cChunkData::cChunkData(cAllocationPool<cChunkData::sChunkSection> & a_Pool): - m_Sections(), - 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] = a_Other.m_Sections[i]; - a_Other.m_Sections[i] = nullptr; - } -} - - - - - -cChunkData::~cChunkData() -{ - Clear(); -} - - - - -void cChunkData::Assign(const cChunkData & a_Other) -{ - // If assigning to self, no-op - if (&a_Other == this) - { - return; - } - - Clear(); - for (size_t i = 0; i < NumSections; ++i) - { - if (a_Other.m_Sections[i] != nullptr) + return { - m_Sections[i] = Allocate(); - *m_Sections[i] = *a_Other.m_Sections[i]; - } - } -} - - - - - -void cChunkData::Assign(cChunkData && a_Other) -{ - if (&a_Other == this) - { - return; - } - - if (m_Pool != a_Other.m_Pool) - { - // Cannot transfer the memory, do a copy instead - const cChunkData & CopyOther = a_Other; - Assign(CopyOther); - return; - } - - Clear(); - for (size_t i = 0; i < NumSections; i++) - { - m_Sections[i] = a_Other.m_Sections[i]; - a_Other.m_Sections[i] = nullptr; - } -} - - - - - -BLOCKTYPE cChunkData::GetBlock(Vector3i a_RelPos) const -{ - if (!cChunkDef::IsValidRelPos(a_RelPos)) - { - return E_BLOCK_AIR; // Coordinates are outside outside the world, so this must be an air block + static_cast<size_t>(a_RelPos.y / cChunkDef::SectionHeight), + static_cast<size_t>(cChunkDef::MakeIndexNoCheck(a_RelPos.x, a_RelPos.y % cChunkDef::SectionHeight, a_RelPos.z)) + }; } - auto Idxs = IndicesFromRelPos(a_RelPos); - if (m_Sections[Idxs.Section] != nullptr) - { - return m_Sections[Idxs.Section]->m_BlockTypes[Idxs.Index]; - } - else - { - return 0; - } -} - - - - -void cChunkData::SetBlock(Vector3i a_RelPos, BLOCKTYPE a_Block) -{ - if (!cChunkDef::IsValidRelPos(a_RelPos)) + bool IsCompressed(const size_t ElementCount) { - ASSERT(!"cChunkData::SetMeta(): index out of range!"); - return; + return ElementCount != ChunkBlockData::SectionBlockCount; } - auto Idxs = IndicesFromRelPos(a_RelPos); - if (m_Sections[Idxs.Section] == nullptr) + template <size_t ElementCount, typename ValueType> + ValueType UnpackDefaultValue(const ValueType DefaultValue) { - if (a_Block == 0x00) - { - return; - } - m_Sections[Idxs.Section] = Allocate(); - if (m_Sections[Idxs.Section] == nullptr) + if (IsCompressed(ElementCount)) { - ASSERT(!"Failed to allocate a new section in Chunkbuffer"); - return; + return DefaultValue & 0xF; } - ZeroSection(m_Sections[Idxs.Section]); - } - m_Sections[Idxs.Section]->m_BlockTypes[Idxs.Index] = a_Block; -} - - - - -NIBBLETYPE cChunkData::GetMeta(Vector3i a_RelPos) const -{ - if (cChunkDef::IsValidRelPos(a_RelPos)) - { - auto Idxs = IndicesFromRelPos(a_RelPos); - if (m_Sections[Idxs.Section] != nullptr) - { - return (m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4)) & 0x0f; - } - else - { - return 0; - } + return DefaultValue; } - // Coordinates are outside outside the world, so it must be an air block with a blank meta - return 0; -} +} // namespace (anonymous) -bool cChunkData::SetMeta(Vector3i a_RelPos, NIBBLETYPE a_Nibble) +template<class ElementType, size_t ElementCount, ElementType DefaultValue> +void ChunkDataStore<ElementType, ElementCount, DefaultValue>::Assign(const ChunkDataStore<ElementType, ElementCount, DefaultValue> & a_Other) { - if (!cChunkDef::IsValidRelPos(a_RelPos)) + for (size_t Y = 0; Y != cChunkDef::NumSections; Y++) { - ASSERT(!"cChunkData::SetMeta(): index out of range!"); - return false; - } + Store[Y].reset(); - auto Idxs = IndicesFromRelPos(a_RelPos); - if (m_Sections[Idxs.Section] == nullptr) - { - if ((a_Nibble & 0xf) == 0x00) - { - return false; - } - m_Sections[Idxs.Section] = Allocate(); - if (m_Sections[Idxs.Section] == nullptr) + if (const auto & Other = a_Other.Store[Y]; Other != nullptr) { - ASSERT(!"Failed to allocate a new section in Chunkbuffer"); - return false; + Store[Y] = std::make_unique<Type>(*Other); } - ZeroSection(m_Sections[Idxs.Section]); } - NIBBLETYPE oldval = m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4) & 0xf; - m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] = static_cast<NIBBLETYPE>( - (m_Sections[Idxs.Section]->m_BlockMetas[Idxs.Index / 2] & (0xf0 >> ((Idxs.Index & 1) * 4))) | // The untouched nibble - ((a_Nibble & 0x0f) << ((Idxs.Index & 1) * 4)) // The nibble being set - ); - return oldval != a_Nibble; } -NIBBLETYPE cChunkData::GetBlockLight(Vector3i a_RelPos) const +template<class ElementType, size_t ElementCount, ElementType DefaultValue> +ElementType ChunkDataStore<ElementType, ElementCount, DefaultValue>::Get(const Vector3i a_Position) const { - if (cChunkDef::IsValidRelPos(a_RelPos)) - { - auto Idxs = IndicesFromRelPos(a_RelPos); - if (m_Sections[Idxs.Section] != nullptr) - { - return (m_Sections[Idxs.Section]->m_BlockLight[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4)) & 0x0f; - } - else - { - return 0; - } - } - ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!"); - return 0; -} - + const auto Indices = IndicesFromRelPos(a_Position); + const auto & Section = Store[Indices.Section]; - - - -NIBBLETYPE cChunkData::GetSkyLight(Vector3i a_RelPos) const -{ - if (cChunkDef::IsValidRelPos(a_RelPos)) + if (Section != nullptr) { - auto Idxs = IndicesFromRelPos(a_RelPos); - if (m_Sections[Idxs.Section] != nullptr) + if (IsCompressed(ElementCount)) { - return (m_Sections[Idxs.Section]->m_BlockSkyLight[Idxs.Index / 2] >> ((Idxs.Index & 1) * 4)) & 0x0f; + return cChunkDef::ExpandNibble(Section->data(), Indices.Index); } else { - return 0xF; + return (*Section)[Indices.Index]; } } - ASSERT(!"cChunkData::GetMeta(): coords out of chunk range!"); - return 0; -} - - - - - -const cChunkData::sChunkSection * cChunkData::GetSection(size_t a_SectionNum) const -{ - if (a_SectionNum < NumSections) - { - 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) - { - Free(m_Sections[i]); - m_Sections[i] = nullptr; - } - } + return UnpackDefaultValue<ElementCount>(DefaultValue); } -void cChunkData::CopyBlockTypes(BLOCKTYPE * a_Dest, size_t a_Idx, size_t a_Length) const +template<class ElementType, size_t ElementCount, ElementType DefaultValue> +typename ChunkDataStore<ElementType, ElementCount, DefaultValue>::Type * ChunkDataStore<ElementType, ElementCount, DefaultValue>::GetSection(const size_t a_Y) const { - size_t ToSkip = a_Idx; - - for (size_t i = 0; i < NumSections; i++) - { - size_t StartPos = 0; - if (ToSkip > 0) - { - StartPos = std::min(ToSkip, +SectionBlockCount); - ToSkip -= StartPos; - } - if (StartPos < SectionBlockCount) - { - size_t ToCopy = std::min(+SectionBlockCount - StartPos, a_Length); - a_Length -= ToCopy; - if (m_Sections[i] != nullptr) - { - BLOCKTYPE * blockbuffer = m_Sections[i]->m_BlockTypes; - memcpy(&a_Dest[(i * SectionBlockCount) + StartPos - a_Idx], blockbuffer + StartPos, sizeof(BLOCKTYPE) * ToCopy); - } - else - { - memset(&a_Dest[(i * SectionBlockCount) + StartPos - a_Idx], 0, sizeof(BLOCKTYPE) * ToCopy); - } - } - } + return Store[a_Y].get(); } -void cChunkData::CopyMetas(NIBBLETYPE * a_Dest) const +template<class ElementType, size_t ElementCount, ElementType DefaultValue> +void ChunkDataStore<ElementType, ElementCount, DefaultValue>::Set(const Vector3i a_Position, const ElementType a_Value) { - for (size_t i = 0; i < NumSections; i++) - { - if (m_Sections[i] != nullptr) - { - memcpy(&a_Dest[i * SectionBlockCount / 2], &m_Sections[i]->m_BlockMetas, sizeof(m_Sections[i]->m_BlockMetas)); - } - else - { - memset(&a_Dest[i * SectionBlockCount / 2], 0, sizeof(m_Sections[i]->m_BlockMetas)); - } - } -} - - - - + const auto Indices = IndicesFromRelPos(a_Position); + auto & Section = Store[Indices.Section]; -void cChunkData::CopyBlockLight(NIBBLETYPE * a_Dest) const -{ - for (size_t i = 0; i < NumSections; i++) + if (Section == nullptr) { - if (m_Sections[i] != nullptr) - { - memcpy(&a_Dest[i * SectionBlockCount / 2], &m_Sections[i]->m_BlockLight, sizeof(m_Sections[i]->m_BlockLight)); - } - else + if (a_Value == UnpackDefaultValue<ElementCount>(DefaultValue)) { - memset(&a_Dest[i * SectionBlockCount / 2], 0, sizeof(m_Sections[i]->m_BlockLight)); + return; } - } -} - - - - -void cChunkData::CopySkyLight(NIBBLETYPE * a_Dest) const -{ - for (size_t i = 0; i < NumSections; i++) - { - if (m_Sections[i] != nullptr) - { - memcpy(&a_Dest[i * SectionBlockCount / 2], &m_Sections[i]->m_BlockSkyLight, sizeof(m_Sections[i]->m_BlockSkyLight)); - } - else - { - memset(&a_Dest[i * SectionBlockCount / 2], 0xff, sizeof(m_Sections[i]->m_BlockSkyLight)); - } + Section = cpp20::make_unique_for_overwrite<Type>(); + std::fill(Section->begin(), Section->end(), DefaultValue); } -} - - - - -void cChunkData::FillBlockTypes(BLOCKTYPE a_Value) -{ - // If needed, allocate any missing sections - if (a_Value != 0x00) + if (IsCompressed(ElementCount)) { - for (auto & Section : m_Sections) - { - if (Section == nullptr) - { - Section = Allocate(); - std::fill(std::begin(Section->m_BlockMetas), std::end(Section->m_BlockMetas), 0x00); - std::fill(std::begin(Section->m_BlockLight), std::end(Section->m_BlockLight), 0x00); - std::fill(std::begin(Section->m_BlockSkyLight), std::end(Section->m_BlockSkyLight), 0xff); - } - } + cChunkDef::PackNibble(Section->data(), Indices.Index, a_Value); } - - for (auto Section : m_Sections) + else { - if (Section != nullptr) - { - std::fill(std::begin(Section->m_BlockTypes), std::end(Section->m_BlockTypes), a_Value); - } + (*Section)[Indices.Index] = a_Value; } } @@ -451,61 +135,20 @@ void cChunkData::FillBlockTypes(BLOCKTYPE a_Value) -void cChunkData::FillMetas(NIBBLETYPE a_Value) +template<class ElementType, size_t ElementCount, ElementType DefaultValue> +void ChunkDataStore<ElementType, ElementCount, DefaultValue>::SetSection(const ElementType (& a_Source)[ElementCount], const size_t a_Y) { - // If needed, allocate any missing sections - if (a_Value != 0x00) - { - for (auto & Section : m_Sections) - { - if (Section == nullptr) - { - Section = Allocate(); - std::fill(std::begin(Section->m_BlockTypes), std::end(Section->m_BlockTypes), 0x00); - std::fill(std::begin(Section->m_BlockLight), std::end(Section->m_BlockLight), 0x00); - std::fill(std::begin(Section->m_BlockSkyLight), std::end(Section->m_BlockSkyLight), 0xff); - } - } - } - - NIBBLETYPE NewMeta = static_cast<NIBBLETYPE>((a_Value << 4) | a_Value); - for (auto Section : m_Sections) - { - if (Section != nullptr) - { - std::fill(std::begin(Section->m_BlockMetas), std::end(Section->m_BlockMetas), NewMeta); - } - } -} - - + auto & Section = Store[a_Y]; + const auto SourceEnd = std::end(a_Source); - - -void cChunkData::FillBlockLight(NIBBLETYPE a_Value) -{ - // If needed, allocate any missing sections - if (a_Value != 0x00) + if (Section != nullptr) { - for (auto & Section : m_Sections) - { - if (Section == nullptr) - { - Section = Allocate(); - std::fill(std::begin(Section->m_BlockTypes), std::end(Section->m_BlockTypes), 0x00); - std::fill(std::begin(Section->m_BlockMetas), std::end(Section->m_BlockMetas), 0x00); - std::fill(std::begin(Section->m_BlockSkyLight), std::end(Section->m_BlockSkyLight), 0xff); - } - } + std::copy(a_Source, SourceEnd, Section->begin()); } - - NIBBLETYPE NewLight = static_cast<NIBBLETYPE>((a_Value << 4) | a_Value); - for (auto Section : m_Sections) + else if (std::any_of(a_Source, SourceEnd, [](const auto Value) { return Value != DefaultValue; })) { - if (Section != nullptr) - { - std::fill(std::begin(Section->m_BlockLight), std::end(Section->m_BlockLight), NewLight); - } + Section = cpp20::make_unique_for_overwrite<Type>(); + std::copy(a_Source, SourceEnd, Section->begin()); } } @@ -513,30 +156,12 @@ void cChunkData::FillBlockLight(NIBBLETYPE a_Value) -void cChunkData::FillSkyLight(NIBBLETYPE a_Value) +template<class ElementType, size_t ElementCount, ElementType DefaultValue> +void ChunkDataStore<ElementType, ElementCount, DefaultValue>::SetAll(const ElementType (& a_Source)[cChunkDef::NumSections * ElementCount]) { - // If needed, allocate any missing sections - if (a_Value != 0x0f) + for (size_t Y = 0; Y != cChunkDef::NumSections; Y++) { - for (auto & Section : m_Sections) - { - if (Section == nullptr) - { - Section = Allocate(); - std::fill(std::begin(Section->m_BlockTypes), std::end(Section->m_BlockTypes), 0x00); - std::fill(std::begin(Section->m_BlockMetas), std::end(Section->m_BlockMetas), 0x00); - std::fill(std::begin(Section->m_BlockLight), std::end(Section->m_BlockLight), 0x00); - } - } - } - - NIBBLETYPE NewSkyLight = static_cast<NIBBLETYPE>((a_Value << 4) | a_Value); - for (auto Section : m_Sections) - { - if (Section != nullptr) - { - std::fill(std::begin(Section->m_BlockSkyLight), std::end(Section->m_BlockSkyLight), NewSkyLight); - } + SetSection(*reinterpret_cast<const ElementType (*)[ElementCount]>(a_Source + Y * ElementCount), Y); } } @@ -544,187 +169,66 @@ void cChunkData::FillSkyLight(NIBBLETYPE a_Value) -void cChunkData::SetBlockTypes(const BLOCKTYPE * a_Src) -{ - ASSERT(a_Src != nullptr); - - for (size_t i = 0; i < NumSections; i++) - { - // If the section is already allocated, copy the data into it: - if (m_Sections[i] != nullptr) - { - memcpy(m_Sections[i]->m_BlockTypes, &a_Src[i * SectionBlockCount], sizeof(m_Sections[i]->m_BlockTypes)); - continue; - } - - // The section doesn't exist, find out if it is needed: - if (IsAllValue(a_Src + i * SectionBlockCount, SectionBlockCount, static_cast<BLOCKTYPE>(0))) - { - // No need for the section, the data is all-air - continue; - } - - // Allocate the section and copy the data into it: - m_Sections[i] = Allocate(); - memcpy(m_Sections[i]->m_BlockTypes, &a_Src[i * SectionBlockCount], sizeof(m_Sections[i]->m_BlockTypes)); - memset(m_Sections[i]->m_BlockMetas, 0x00, sizeof(m_Sections[i]->m_BlockMetas)); - memset(m_Sections[i]->m_BlockLight, 0x00, sizeof(m_Sections[i]->m_BlockLight)); - memset(m_Sections[i]->m_BlockSkyLight, 0xff, sizeof(m_Sections[i]->m_BlockSkyLight)); - } // for i - m_Sections[] -} - - - - - -void cChunkData::SetMetas(const NIBBLETYPE * a_Src) +void ChunkBlockData::Assign(const ChunkBlockData & a_Other) { - ASSERT(a_Src != nullptr); - - for (size_t i = 0; i < NumSections; i++) - { - // If the section is already allocated, copy the data into it: - if (m_Sections[i] != nullptr) - { - memcpy(m_Sections[i]->m_BlockMetas, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockMetas)); - continue; - } - - // The section doesn't exist, find out if it is needed: - if (IsAllValue(a_Src + i * SectionBlockCount / 2, SectionBlockCount / 2, static_cast<NIBBLETYPE>(0))) - { - // No need for the section, the data is all zeroes - continue; - } - - // Allocate the section and copy the data into it: - m_Sections[i] = Allocate(); - memcpy(m_Sections[i]->m_BlockMetas, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockMetas)); - memset(m_Sections[i]->m_BlockTypes, 0x00, sizeof(m_Sections[i]->m_BlockTypes)); - memset(m_Sections[i]->m_BlockLight, 0x00, sizeof(m_Sections[i]->m_BlockLight)); - memset(m_Sections[i]->m_BlockSkyLight, 0xff, sizeof(m_Sections[i]->m_BlockSkyLight)); - } // for i - m_Sections[] + m_Blocks.Assign(a_Other.m_Blocks); + m_Metas.Assign(a_Other.m_Metas); } -void cChunkData::SetBlockLight(const NIBBLETYPE * a_Src) +void ChunkBlockData::SetAll(const cChunkDef::BlockTypes & a_BlockSource, const cChunkDef::BlockNibbles & a_MetaSource) { - if (a_Src == nullptr) - { - return; - } - - for (size_t i = 0; i < NumSections; i++) - { - // If the section is already allocated, copy the data into it: - if (m_Sections[i] != nullptr) - { - memcpy(m_Sections[i]->m_BlockLight, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockLight)); - continue; - } - - // The section doesn't exist, find out if it is needed: - if (IsAllValue(a_Src + i * SectionBlockCount / 2, SectionBlockCount / 2, static_cast<NIBBLETYPE>(0))) - { - // No need for the section, the data is all zeroes - continue; - } - - // Allocate the section and copy the data into it: - m_Sections[i] = Allocate(); - memcpy(m_Sections[i]->m_BlockLight, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockLight)); - memset(m_Sections[i]->m_BlockTypes, 0x00, sizeof(m_Sections[i]->m_BlockTypes)); - memset(m_Sections[i]->m_BlockMetas, 0x00, sizeof(m_Sections[i]->m_BlockMetas)); - memset(m_Sections[i]->m_BlockSkyLight, 0xff, sizeof(m_Sections[i]->m_BlockSkyLight)); - } // for i - m_Sections[] + m_Blocks.SetAll(a_BlockSource); + m_Metas.SetAll(a_MetaSource); } -void cChunkData::SetSkyLight(const NIBBLETYPE * a_Src) +void ChunkBlockData::SetSection(const SectionType & a_BlockSource, const SectionMetaType & a_MetaSource, const size_t a_Y) { - if (a_Src == nullptr) - { - return; - } - - for (size_t i = 0; i < NumSections; i++) - { - // If the section is already allocated, copy the data into it: - if (m_Sections[i] != nullptr) - { - memcpy(m_Sections[i]->m_BlockSkyLight, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockSkyLight)); - continue; - } - - // The section doesn't exist, find out if it is needed: - if (IsAllValue(a_Src + i * SectionBlockCount / 2, SectionBlockCount / 2, static_cast<NIBBLETYPE>(0xff))) - { - // No need for the section, the data is all zeroes - continue; - } - - // Allocate the section and copy the data into it: - m_Sections[i] = Allocate(); - memcpy(m_Sections[i]->m_BlockSkyLight, &a_Src[i * SectionBlockCount / 2], sizeof(m_Sections[i]->m_BlockSkyLight)); - memset(m_Sections[i]->m_BlockTypes, 0x00, sizeof(m_Sections[i]->m_BlockTypes)); - memset(m_Sections[i]->m_BlockMetas, 0x00, sizeof(m_Sections[i]->m_BlockMetas)); - memset(m_Sections[i]->m_BlockLight, 0x00, sizeof(m_Sections[i]->m_BlockLight)); - } // for i - m_Sections[] + m_Blocks.SetSection(a_BlockSource, a_Y); + m_Metas.SetSection(a_MetaSource, a_Y); } -UInt32 cChunkData::NumPresentSections() const +void ChunkLightData::Assign(const ChunkLightData & a_Other) { - UInt32 Ret = 0U; - for (size_t i = 0; i < NumSections; i++) - { - if (m_Sections[i] != nullptr) - { - ++Ret; - } - } - return Ret; + m_BlockLights.Assign(a_Other.m_BlockLights); + m_SkyLights.Assign(a_Other.m_SkyLights); } -cChunkData::sChunkSection * cChunkData::Allocate(void) +void ChunkLightData::SetAll(const cChunkDef::BlockNibbles & a_BlockLightSource, const cChunkDef::BlockNibbles & a_SkyLightSource) { - return m_Pool.Allocate(); + m_BlockLights.SetAll(a_BlockLightSource); + m_SkyLights.SetAll(a_SkyLightSource); } -void cChunkData::Free(cChunkData::sChunkSection * a_Section) +void ChunkLightData::SetSection(const SectionType & a_BlockLightSource, const SectionType & a_SkyLightSource, const size_t a_Y) { - m_Pool.Free(a_Section); + m_BlockLights.SetSection(a_BlockLightSource, a_Y); + m_SkyLights.SetSection(a_SkyLightSource, a_Y); } -void cChunkData::ZeroSection(cChunkData::sChunkSection * a_Section) const -{ - memset(a_Section->m_BlockTypes, 0x00, sizeof(a_Section->m_BlockTypes)); - memset(a_Section->m_BlockMetas, 0x00, sizeof(a_Section->m_BlockMetas)); - memset(a_Section->m_BlockLight, 0x00, sizeof(a_Section->m_BlockLight)); - memset(a_Section->m_BlockSkyLight, 0xff, sizeof(a_Section->m_BlockSkyLight)); -} - - - - +template struct ChunkDataStore<BLOCKTYPE, ChunkBlockData::SectionBlockCount, ChunkBlockData::DefaultValue>; +template struct ChunkDataStore<NIBBLETYPE, ChunkBlockData::SectionMetaCount, ChunkLightData::DefaultBlockLightValue>; +template struct ChunkDataStore<NIBBLETYPE, ChunkLightData::SectionLightCount, ChunkLightData::DefaultSkyLightValue>; |