#include "generator.hpp"
+#include <algorithm>
#include <limits>
#include <queue>
#include <glm/gtx/transform.hpp>
Chunk::Chunk(const BlockTypeRegistry &types)
: types(&types)
-, neighbor{ 0, 0, 0, 0, 0, 0 }
-, blocks()
-, light()
+, neighbor{0}
+, blocks{}
+, light{0}
, model()
, position(0, 0, 0)
, dirty(false) {
Chunk::Chunk(Chunk &&other)
: types(other.types)
-, blocks(std::move(other.blocks))
-, light(std::move(other.light))
, model(std::move(other.model))
, position(other.position)
, dirty(other.dirty) {
- for (size_t i = 0; i < Block::FACE_COUNT; ++i) {
- neighbor[i] = other.neighbor[i];
- }
+ std::copy(other.neighbor, other.neighbor + sizeof(neighbor), neighbor);
+ std::copy(other.blocks, other.blocks + sizeof(blocks), blocks);
+ std::copy(other.light, other.light + sizeof(light), light);
}
Chunk &Chunk::operator =(Chunk &&other) {
types = other.types;
- for (size_t i = 0; i < Block::FACE_COUNT; ++i) {
- neighbor[i] = other.neighbor[i];
- }
- blocks = std::move(other.blocks);
- light = std::move(other.light);
+ std::copy(other.neighbor, other.neighbor + sizeof(neighbor), neighbor);
+ std::copy(other.blocks, other.blocks + sizeof(blocks), blocks);
+ std::copy(other.light, other.light + sizeof(light), light);
model = std::move(other.model);
position = other.position;
dirty = other.dirty;
bool HasNext(Block::Face face) {
const BlockLookup next(chunk, pos, face);
- return next.result && !next.chunk->Type(*next.result).block_light;
+ return next && !next.GetType().block_light;
}
SetNode GetNext(Block::Face face) {
const BlockLookup next(chunk, pos, face);
- return SetNode(next.chunk, next.pos);
+ return SetNode(&next.GetChunk(), next.GetBlockPos());
}
};
bool HasNext(Block::Face face) {
const BlockLookup next(chunk, pos, face);
- return next.result;
+ return next;
}
UnsetNode GetNext(Block::Face face) { return UnsetNode(SetNode::GetNext(face)); }
Chunk::Pos pos(ToPos(index));
Block::Face direct_face(Block::NormalFace(norm));
- const Chunk *direct_chunk = this;
- Chunk::Pos direct_pos(pos + Block::FaceNormal(direct_face));
- if (!InBounds(direct_pos)) {
- if (HasNeighbor(direct_face)) {
- direct_chunk = &GetNeighbor(direct_face);
- direct_pos -= (Block::FaceNormal(direct_face) * Extent());
- float direct_light = direct_chunk->GetLight(direct_pos);
- if (direct_light > light) {
- light = direct_light;
- }
- }
- } else {
- float direct_light = direct_chunk->GetLight(direct_pos);
+ // tis okay
+ BlockLookup direct(const_cast<Chunk *>(this), pos, Block::NormalFace(norm));
+ if (direct) {
+ float direct_light = direct.GetLight();
if (direct_light > light) {
light = direct_light;
}
}
-void Chunk::Allocate() {
- blocks.resize(Size(), Block(0));
- light.resize(Size(), 0);
-}
-
-
void Chunk::Draw() {
if (dirty) {
Update();
BlockLookup::BlockLookup(Chunk *c, const Chunk::Pos &p)
-: chunk(c), pos(p), result(nullptr) {
+: chunk(c), pos(p) {
while (pos.x >= Chunk::Width()) {
if (chunk->HasNeighbor(Block::FACE_RIGHT)) {
chunk = &chunk->GetNeighbor(Block::FACE_RIGHT);
pos.x -= Chunk::Width();
} else {
+ chunk = nullptr;
return;
}
}
chunk = &chunk->GetNeighbor(Block::FACE_LEFT);
pos.x += Chunk::Width();
} else {
+ chunk = nullptr;
return;
}
}
chunk = &chunk->GetNeighbor(Block::FACE_UP);
pos.y -= Chunk::Height();
} else {
+ chunk = nullptr;
return;
}
}
chunk = &chunk->GetNeighbor(Block::FACE_DOWN);
pos.y += Chunk::Height();
} else {
+ chunk = nullptr;
return;
}
}
chunk = &chunk->GetNeighbor(Block::FACE_FRONT);
pos.z -= Chunk::Depth();
} else {
+ chunk = nullptr;
return;
}
}
chunk = &chunk->GetNeighbor(Block::FACE_BACK);
pos.z += Chunk::Depth();
} else {
+ chunk = nullptr;
return;
}
}
- result = &chunk->BlockAt(pos);
}
BlockLookup::BlockLookup(Chunk *c, const Chunk::Pos &p, Block::Face face)
-: chunk(c), pos(p), result(nullptr) {
+: chunk(c), pos(p) {
pos += Block::FaceNormal(face);
- if (Chunk::InBounds(pos)) {
- result = &chunk->BlockAt(pos);
- } else {
+ if (!Chunk::InBounds(pos)) {
pos -= Block::FaceNormal(face) * Chunk::Extent();
- if (chunk->HasNeighbor(face)) {
- chunk = &chunk->GetNeighbor(face);
- result = &chunk->BlockAt(pos);
- }
+ chunk = &chunk->GetNeighbor(face);
}
}
loaded.emplace_back(reg);
Chunk &chunk = loaded.back();
chunk.Position(pos);
- chunk.Allocate();
gen(chunk);
Insert(chunk);
return chunk;
}
void ChunkLoader::Update() {
- bool reused = false;
- if (!to_generate.empty()) {
- Chunk::Pos pos(to_generate.front());
-
- for (auto iter(to_free.begin()), end(to_free.end()); iter != end; ++iter) {
- if (iter->Position() == pos) {
- iter->Relink();
- loaded.splice(loaded.end(), to_free, iter);
- reused = true;
- break;
- }
- }
+ if (to_generate.empty()) {
+ return;
+ }
- if (!reused) {
- if (to_free.empty()) {
- loaded.emplace_back(reg);
- } else {
- to_free.front().ClearNeighbors();
- loaded.splice(loaded.end(), to_free, to_free.begin());
- reused = true;
- }
- Chunk &chunk = loaded.back();
- chunk.Position(pos);
- chunk.Allocate();
- gen(chunk);
- Insert(chunk);
+ Chunk::Pos pos(to_generate.front());
+ to_generate.pop_front();
+
+ for (auto iter(to_free.begin()), end(to_free.end()); iter != end; ++iter) {
+ if (iter->Position() == pos) {
+ iter->Relink();
+ loaded.splice(loaded.end(), to_free, iter);
+ return;
}
- to_generate.pop_front();
}
- if (!reused && !to_free.empty()) {
- to_free.pop_front();
+ if (to_free.empty()) {
+ loaded.emplace_back(reg);
+ } else {
+ to_free.front().ClearNeighbors();
+ loaded.splice(loaded.end(), to_free, to_free.begin());
}
+ Chunk &chunk = loaded.back();
+ chunk.Position(pos);
+ gen(chunk);
+ Insert(chunk);
}
}