neocturne/MinedMap
1
0
Fork 0
mirror of https://github.com/neocturne/MinedMap.git synced 2025-03-05 17:44:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Performance improvements

Browse source
This commit is contained in:
Matthias Schiffer 2015-02-01 14:35:31 +01:00
parent 8b09f6f4ec
commit e880f8997f
3 changed files with 74 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
src/NBT/ByteArrayTag.hpp
View file

@ -55,15 +55,8 @@ public:
return len; return len;
} }
const uint8_t & get(size_t i) const { const uint8_t * getValue() const {
return value[i]; return value;
}
uint8_t getHalf(size_t i) const {
if (i % 2)
return (value[i/2] >> 4);
else
return (value[i/2] & 0xf);
} }
}; };

64
src/World/Chunk.cpp
View file

@ -30,6 +30,7 @@
#include <iostream> #include <iostream>
#include <stdexcept> #include <stdexcept>
#include <cstdlib> #include <cstdlib>
#include <cstring>
#include <zlib.h> #include <zlib.h>
@ -101,27 +102,32 @@ void Chunk::analyzeChunk() {
if (!lightPopulatedTag && lightPopulatedTag->getValue()) if (!lightPopulatedTag && lightPopulatedTag->getValue())
throw std::invalid_argument("light data missing"); throw std::invalid_argument("light data missing");
for (auto &section : *assertValue(level->get<NBT::ListTag<NBT::CompoundTag>>("Sections"))) sections = assertValue(level->get<NBT::ListTag<NBT::CompoundTag>>("Sections"));
sections.emplace_back(*section); maxY = (assertValue(sections->back()->get<NBT::ByteTag>("Y"))->getValue() + 1) * SIZE;
maxY = sections.back().getY() + SIZE; blockIDs.reset(new uint8_t[maxY * SIZE * SIZE]);
blocks.reset(new Block[maxY * SIZE * SIZE]); blockData.reset(new uint8_t[maxY * SIZE * SIZE / 2]);
blockSkyLight.reset(new uint8_t[maxY * SIZE * SIZE / 2]);
blockBlockLight.reset(new uint8_t[maxY * SIZE * SIZE / 2]);
for (auto &section : sections) { std::memset(blockSkyLight.get(), 0xff, maxY * SIZE * SIZE / 2);
unsigned Y = section.getY();
for (size_t y = 0; y < SIZE; y++) {
for (size_t z = 0; z < SIZE; z++) {
for (size_t x = 0; x < SIZE; x++) {
Block &block = getBlock(x, Y+y, z);
block.id = section.getBlockAt(x, y, z); for (auto &section : *sections) {
block.data = section.getDataAt(x, y, z); std::shared_ptr<const NBT::ByteArrayTag> blocks = assertValue(section->get<NBT::ByteArrayTag>("Blocks"));
block.blockLight = section.getBlockLightAt(x, y, z); std::shared_ptr<const NBT::ByteArrayTag> data = assertValue(section->get<NBT::ByteArrayTag>("Data"));
block.skyLight = section.getSkyLightAt(x, y, z); std::shared_ptr<const NBT::ByteArrayTag> blockLight = assertValue(section->get<NBT::ByteArrayTag>("BlockLight"));
} std::shared_ptr<const NBT::ByteArrayTag> skyLight = assertValue(section->get<NBT::ByteArrayTag>("SkyLight"));
} size_t Y = assertValue(section->get<NBT::ByteTag>("Y"))->getValue();
}
if (blocks->getLength() != SIZE*SIZE*SIZE || data->getLength() != SIZE*SIZE*SIZE/2
|| blockLight->getLength() != SIZE*SIZE*SIZE/2 || skyLight->getLength() != SIZE*SIZE*SIZE/2)
throw std::invalid_argument("corrupt chunk data");
std::memcpy(blockIDs.get() + Y*SIZE*SIZE*SIZE, blocks->getValue(), SIZE*SIZE*SIZE);
std::memcpy(blockData.get() + Y*SIZE*SIZE*SIZE/2, data->getValue(), SIZE*SIZE*SIZE/2);
std::memcpy(blockBlockLight.get() + Y*SIZE*SIZE*SIZE/2, blockLight->getValue(), SIZE*SIZE*SIZE/2);
std::memcpy(blockSkyLight.get() + Y*SIZE*SIZE*SIZE/2, skyLight->getValue(), SIZE*SIZE*SIZE/2);
} }
} }
@ -138,29 +144,27 @@ Chunk::Blocks Chunk::getTopLayer() const {
if (ret.blocks[x][z].id) if (ret.blocks[x][z].id)
continue; continue;
const Block &block = getBlock(x, y, z); uint8_t id = getBlockAt(x, y, z);
if (!BLOCK_TYPES[block.id].opaque) if (!BLOCK_TYPES[id].opaque)
continue; continue;
Block &b = ret.blocks[x][z]; Block &b = ret.blocks[x][z];
b.id = block.id; b.id = id;
b.data = block.data; b.data = getDataAt(x, y, z);
const Block *lightBlock; size_t y2 = y;
if (y < maxY-1) if (y2 < maxY-1)
lightBlock = &getBlock(x, y+1, z); y2++;
else
lightBlock = &block;
b.blockLight = lightBlock->blockLight; b.blockLight = getBlockLightAt(x, y2, z);
b.skyLight = lightBlock->skyLight; b.skyLight = getSkyLightAt(x, y2, z);
unsigned h; unsigned h;
for (h = y; h > 0; h--) { for (h = y; h > 0; h--) {
const Block &block2 = getBlock(x, h, z); uint8_t id2 = getBlockAt(x, h, z);
if (block2.id != 8 && block2.id != 9) if (id2 != 8 && id2 != 9)
break; break;
} }

98
src/World/Chunk.hpp
View file

@ -47,83 +47,61 @@ class Chunk {
public: public:
static const size_t SIZE = 16; static const size_t SIZE = 16;
class Section {
private:
static size_t getIndex(size_t x, size_t y, size_t z) {
if (x >= SIZE || y >= SIZE || z >= SIZE)
throw std::range_error("Chunk::getIndex(): bad coordinates");
return SIZE*SIZE*y + SIZE*z + x;
}
std::shared_ptr<const NBT::ByteArrayTag> blocks;
std::shared_ptr<const NBT::ByteArrayTag> data;
std::shared_ptr<const NBT::ByteArrayTag> blockLight;
std::shared_ptr<const NBT::ByteArrayTag> skyLight;
unsigned Y;
public:
Section(const NBT::CompoundTag &s) {
blocks = assertValue(s.get<NBT::ByteArrayTag>("Blocks"));
data = assertValue(s.get<NBT::ByteArrayTag>("Data"));
blockLight = assertValue(s.get<NBT::ByteArrayTag>("BlockLight"));
skyLight = assertValue(s.get<NBT::ByteArrayTag>("SkyLight"));
if (blocks->getLength() != SIZE*SIZE*SIZE || data->getLength() != SIZE*SIZE*SIZE/2
|| blockLight->getLength() != SIZE*SIZE*SIZE/2 || skyLight->getLength() != SIZE*SIZE*SIZE/2)
throw std::invalid_argument("corrupt chunk data");
Y = assertValue(s.get<NBT::ByteTag>("Y"))->getValue() * SIZE;
}
uint8_t getBlockAt(size_t x, size_t y, size_t z) const {
return blocks->get(getIndex(x, y, z));
}
uint8_t getDataAt(size_t x, size_t y, size_t z) const {
return data->getHalf(getIndex(x, y, z));
}
uint8_t getBlockLightAt(size_t x, size_t y, size_t z) const {
return blockLight->getHalf(getIndex(x, y, z));
}
uint8_t getSkyLightAt(size_t x, size_t y, size_t z) const {
return skyLight->getHalf(getIndex(x, y, z));
}
unsigned getY() const {
return Y;
}
};
struct Blocks { struct Blocks {
Block blocks[SIZE][SIZE]; Block blocks[SIZE][SIZE];
}; };
private: private:
size_t len; size_t len;
UniqueCPtr<uint8_t[]> data; UniqueCPtr<uint8_t[]> data;
std::shared_ptr<const NBT::CompoundTag> root; std::shared_ptr<const NBT::CompoundTag> root;
std::shared_ptr<const NBT::CompoundTag> level; std::shared_ptr<const NBT::CompoundTag> level;
std::shared_ptr<const NBT::ListTag<NBT::CompoundTag>> sections;
std::vector<Section> sections;
unsigned maxY; unsigned maxY;
std::unique_ptr<Block[]> blocks; std::unique_ptr<uint8_t[]> blockIDs;
std::unique_ptr<uint8_t[]> blockData;
std::unique_ptr<uint8_t[]> blockSkyLight;
std::unique_ptr<uint8_t[]> blockBlockLight;
Block & getBlock(size_t x, size_t y, size_t z) {
return blocks[SIZE*SIZE*y + SIZE*z + x]; size_t getIndex(size_t x, size_t y, size_t z) const {
if (x >= SIZE || y >= maxY || z >= SIZE)
throw std::range_error("Chunk::getIndex(): bad coordinates");
return SIZE*SIZE*y + SIZE*z + x;
} }
const Block & getBlock(size_t x, size_t y, size_t z) const { uint8_t getHalf(const uint8_t *v, size_t x, size_t y, size_t z) const {
return blocks[SIZE*SIZE*y + SIZE*z + x]; size_t i = getIndex(x, y, z);
if (i % 2)
return (v[i/2] >> 4);
else
return (v[i/2] & 0xf);
} }
uint8_t getBlockAt(size_t x, size_t y, size_t z) const {
return blockIDs[getIndex(x, y, z)];
}
uint8_t getDataAt(size_t x, size_t y, size_t z) const {
return getHalf(blockData.get(), x, y, z);
}
uint8_t getBlockLightAt(size_t x, size_t y, size_t z) const {
return getHalf(blockBlockLight.get(), x, y, z);
}
uint8_t getSkyLightAt(size_t x, size_t y, size_t z) const {
return getHalf(blockSkyLight.get(), x, y, z);
}
void inflateChunk(Buffer buffer); void inflateChunk(Buffer buffer);
void parseChunk(); void parseChunk();
void analyzeChunk(); void analyzeChunk();
@ -135,8 +113,8 @@ public:
return *level; return *level;
} }
const std::vector<Section> & getSections() const { const NBT::ListTag<NBT::CompoundTag> & getSections() const {
return sections; return *sections;
} }
Blocks getTopLayer() const; Blocks getTopLayer() const;