#include "generator.hpp"
#include <limits>
+#include <queue>
#include <glm/gtx/transform.hpp>
-namespace {
-
-blank::Model::Buffer buf;
-
-}
-
namespace blank {
Chunk::Chunk(const BlockTypeRegistry &types)
: types(&types)
, neighbor{ 0, 0, 0, 0, 0, 0 }
, blocks()
+, light()
, 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];
neighbor[i] = other.neighbor[i];
}
blocks = std::move(other.blocks);
+ light = std::move(other.light);
model = std::move(other.model);
+ position = other.position;
dirty = other.dirty;
return *this;
}
void Chunk::SetNeighbor(Chunk &other) {
- if (other.position == position - Pos(-1, 0, 0)) {
+ if (other.position == position + Pos(-1, 0, 0)) {
neighbor[Block::FACE_LEFT] = &other;
other.neighbor[Block::FACE_RIGHT] = this;
- } else if (other.position == position - Pos(1, 0, 0)) {
+ } else if (other.position == position + Pos(1, 0, 0)) {
neighbor[Block::FACE_RIGHT] = &other;
other.neighbor[Block::FACE_LEFT] = this;
- } else if (other.position == position - Pos(0, -1, 0)) {
+ } else if (other.position == position + Pos(0, -1, 0)) {
neighbor[Block::FACE_DOWN] = &other;
other.neighbor[Block::FACE_UP] = this;
- } else if (other.position == position - Pos(0, 1, 0)) {
+ } else if (other.position == position + Pos(0, 1, 0)) {
neighbor[Block::FACE_UP] = &other;
other.neighbor[Block::FACE_DOWN] = this;
- } else if (other.position == position - Pos(0, 0, -1)) {
+ } else if (other.position == position + Pos(0, 0, -1)) {
neighbor[Block::FACE_BACK] = &other;
other.neighbor[Block::FACE_FRONT] = this;
- } else if (other.position == position - Pos(0, 0, 1)) {
+ } else if (other.position == position + Pos(0, 0, 1)) {
neighbor[Block::FACE_FRONT] = &other;
other.neighbor[Block::FACE_BACK] = this;
}
}
+namespace {
+
+struct SetNode {
+
+ Chunk *chunk;
+ Chunk::Pos pos;
+
+ SetNode(Chunk *chunk, Chunk::Pos pos)
+ : chunk(chunk), pos(pos) { }
+
+ int Get() const { return chunk->GetLight(pos); }
+ void Set(int level) { chunk->SetLight(pos, level); }
+
+ bool HasNext(Block::Face face) {
+ const BlockLookup next(chunk, pos, face);
+ return next.result && !next.chunk->Type(*next.result).block_light;
+ }
+ SetNode GetNext(Block::Face face) {
+ const BlockLookup next(chunk, pos, face);
+ return SetNode(next.chunk, next.pos);
+ }
+
+};
+
+struct UnsetNode
+: public SetNode {
+
+ int level;
+
+ UnsetNode(Chunk *chunk, Chunk::Pos pos)
+ : SetNode(chunk, pos), level(Get()) { }
+
+ UnsetNode(const SetNode &set)
+ : SetNode(set), level(Get()) { }
+
+
+ bool HasNext(Block::Face face) {
+ const BlockLookup next(chunk, pos, face);
+ return next.result;
+ }
+ UnsetNode GetNext(Block::Face face) { return UnsetNode(SetNode::GetNext(face)); }
+
+};
+
+std::queue<SetNode> light_queue;
+std::queue<UnsetNode> dark_queue;
+
+void work_light() {
+ while (!light_queue.empty()) {
+ SetNode node = light_queue.front();
+ light_queue.pop();
+
+ int level = node.Get() - 1;
+ for (int face = 0; face < Block::FACE_COUNT; ++face) {
+ if (node.HasNext(Block::Face(face))) {
+ SetNode other = node.GetNext(Block::Face(face));
+ if (other.Get() < level) {
+ other.Set(level);
+ light_queue.emplace(other);
+ }
+ }
+ }
+ }
+}
+
+void work_dark() {
+ while (!dark_queue.empty()) {
+ UnsetNode node = dark_queue.front();
+ dark_queue.pop();
+
+ for (int face = 0; face < Block::FACE_COUNT; ++face) {
+ if (node.HasNext(Block::Face(face))) {
+ UnsetNode other = node.GetNext(Block::Face(face));
+ // TODO: if there a light source here with the same level this will err
+ if (other.Get() != 0 && other.Get() < node.level) {
+ other.Set(0);
+ dark_queue.emplace(other);
+ } else {
+ light_queue.emplace(other);
+ }
+ }
+ }
+ }
+}
+
+}
+
+void Chunk::SetBlock(int index, const Block &block) {
+ const BlockType &old_type = Type(blocks[index]);
+ const BlockType &new_type = Type(block);
+
+ blocks[index] = block;
+
+ if (&old_type == &new_type) return;
+
+ if (new_type.luminosity > old_type.luminosity) {
+ // light added
+ SetLight(index, new_type.luminosity);
+ light_queue.emplace(this, ToPos(index));
+ work_light();
+ } else if (new_type.luminosity < old_type.luminosity) {
+ // light removed
+ dark_queue.emplace(this, ToPos(index));
+ SetLight(index, 0);
+ work_dark();
+ SetLight(index, new_type.luminosity);
+ light_queue.emplace(this, ToPos(index));
+ work_light();
+ } else if (new_type.block_light && !old_type.block_light) {
+ // obstacle added
+ dark_queue.emplace(this, ToPos(index));
+ SetLight(index, 0);
+ work_dark();
+ work_light();
+ } else if (!new_type.block_light && old_type.block_light) {
+ // obstacle removed
+ int level = 0;
+ for (int face = 0; face < Block::FACE_COUNT; ++face) {
+ Pos next_pos(ToPos(index) + Block::FaceNormal(Block::Face(face)));
+ int next_level = 0;
+ if (InBounds(next_pos)) {
+ next_level = GetLight(next_pos);
+ } else {
+ if (HasNeighbor(Block::Face(face))) {
+ next_pos -= (Block::FaceNormal(Block::Face(face)) * Chunk::Extent());
+ next_level = GetNeighbor(Block::Face(face)).GetLight(next_pos);
+ }
+ }
+ if (level < next_level) {
+ level = next_level;
+ }
+ }
+ if (level > 1) {
+ SetLight(index, level - 1);
+ light_queue.emplace(this, ToPos(index));
+ work_light();
+ }
+ }
+}
+
+const Block *Chunk::FindNext(const Pos &pos, Block::Face face) const {
+ Pos next_pos(pos + Block::FaceNormal(face));
+ if (InBounds(next_pos)) {
+ return &BlockAt(pos + Block::FaceNormal(face));
+ } else if (HasNeighbor(face)) {
+ return &GetNeighbor(face).BlockAt(next_pos - (Block::FaceNormal(face) * Extent()));
+ } else {
+ return nullptr;
+ }
+}
+
+
+void Chunk::SetLight(int index, int level) {
+ if (light[index] != level) {
+ light[index] = level;
+ Invalidate();
+ }
+}
+
+int Chunk::GetLight(int index) const {
+ return light[index];
+}
+
+float Chunk::GetVertexLight(int index, const BlockModel::Position &vtx, const BlockModel::Normal &norm) const {
+ float light = GetLight(index);
+ 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);
+ if (direct_light > light) {
+ light = direct_light;
+ }
+ }
+
+ // cheap alternative until AO etc are implemented
+ // to tell the faces apart
+
+ if (direct_face == Block::FACE_LEFT || direct_face == Block::FACE_RIGHT) {
+ light -= 0.2;
+ } else if (direct_face == Block::FACE_FRONT || direct_face == Block::FACE_BACK) {
+ light -= 0.4;
+ }
+
+ return light;
+}
+
+
+bool Chunk::IsSurface(const Pos &pos) const {
+ const Block &block = BlockAt(pos);
+ if (!Type(block).visible) {
+ return false;
+ }
+ for (int face = 0; face < Block::FACE_COUNT; ++face) {
+ const Block *next = FindNext(pos, Block::Face(face));
+ if (!next || !Type(*next).visible) {
+ return true;
+ }
+ }
+ return false;
+}
+
+
void Chunk::Allocate() {
- blocks.resize(Size());
+ blocks.resize(Size(), Block(0));
+ light.resize(Size(), 0);
}
}
+namespace {
+
+BlockModel::Buffer buf;
+
+}
+
void Chunk::CheckUpdate() {
if (dirty) {
Update();
buf.Clear();
buf.Reserve(vtx_count, idx_count);
- Model::Index vtx_counter = 0;
+ BlockModel::Index vtx_counter = 0;
for (size_t i = 0; i < Size(); ++i) {
const BlockType &type = Type(blocks[i]);
if (!type.visible || Obstructed(i)) continue;
- type.FillModel(buf, ToTransform(i), vtx_counter);
+ type.FillBlockModel(buf, ToTransform(i), vtx_counter);
+ size_t vtx_begin = vtx_counter;
vtx_counter += type.shape->VertexCount();
+
+ for (size_t vtx = vtx_begin; vtx < vtx_counter; ++vtx) {
+ buf.lights.emplace_back(GetVertexLight(i, buf.vertices[vtx], buf.normals[vtx]));
+ }
}
model.Update(buf);
}
-ChunkLoader::ChunkLoader(const BlockTypeRegistry ®, const Generator &gen)
+BlockLookup::BlockLookup(Chunk *c, const Chunk::Pos &p)
+: chunk(c), pos(p), result(nullptr) {
+ while (pos.x >= Chunk::Width()) {
+ if (chunk->HasNeighbor(Block::FACE_RIGHT)) {
+ chunk = &chunk->GetNeighbor(Block::FACE_RIGHT);
+ pos.x -= Chunk::Width();
+ } else {
+ return;
+ }
+ }
+ while (pos.x < 0) {
+ if (chunk->HasNeighbor(Block::FACE_LEFT)) {
+ chunk = &chunk->GetNeighbor(Block::FACE_LEFT);
+ pos.x += Chunk::Width();
+ } else {
+ return;
+ }
+ }
+ while (pos.y >= Chunk::Height()) {
+ if (chunk->HasNeighbor(Block::FACE_UP)) {
+ chunk = &chunk->GetNeighbor(Block::FACE_UP);
+ pos.y -= Chunk::Height();
+ } else {
+ return;
+ }
+ }
+ while (pos.y < 0) {
+ if (chunk->HasNeighbor(Block::FACE_DOWN)) {
+ chunk = &chunk->GetNeighbor(Block::FACE_DOWN);
+ pos.y += Chunk::Height();
+ } else {
+ return;
+ }
+ }
+ while (pos.z >= Chunk::Depth()) {
+ if (chunk->HasNeighbor(Block::FACE_FRONT)) {
+ chunk = &chunk->GetNeighbor(Block::FACE_FRONT);
+ pos.z -= Chunk::Depth();
+ } else {
+ return;
+ }
+ }
+ while (pos.z < 0) {
+ if (chunk->HasNeighbor(Block::FACE_BACK)) {
+ chunk = &chunk->GetNeighbor(Block::FACE_BACK);
+ pos.z += Chunk::Depth();
+ } else {
+ return;
+ }
+ }
+ result = &chunk->BlockAt(pos);
+}
+
+BlockLookup::BlockLookup(Chunk *c, const Chunk::Pos &p, Block::Face face)
+: chunk(c), pos(p), result(nullptr) {
+ pos += Block::FaceNormal(face);
+ if (Chunk::InBounds(pos)) {
+ result = &chunk->BlockAt(pos);
+ } else {
+ pos -= Block::FaceNormal(face) * Chunk::Extent();
+ if (chunk->HasNeighbor(face)) {
+ chunk = &chunk->GetNeighbor(face);
+ result = &chunk->BlockAt(pos);
+ }
+ }
+}
+
+
+ChunkLoader::ChunkLoader(const Config &config, const BlockTypeRegistry ®, const Generator &gen)
: base(0, 0, 0)
, reg(reg)
, gen(gen)
, loaded()
, to_generate()
, to_free()
-, load_dist(4)
-, unload_dist(5) {
+, load_dist(config.load_dist)
+, unload_dist(config.unload_dist) {
}
} else if (pos == base) {
Generate(pos);
+ // light testing
+ // for (int i = 0; i < 16; ++i) {
+ // for (int j = 0; j < 16; ++j) {
+ // loaded.back().SetBlock(Chunk::Pos{ i, j, 0 }, Block(1));
+ // loaded.back().SetBlock(Chunk::Pos{ i, j, 15 }, Block(1));
+ // loaded.back().SetBlock(Chunk::Pos{ 0, j, i }, Block(1));
+ // loaded.back().SetBlock(Chunk::Pos{ 15, j, i }, Block(1));
+ // }
+ // }
+ // loaded.back().SetBlock(Chunk::Pos{ 1, 0, 1 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 14, 0, 1 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 1, 0, 14 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 14, 0, 14 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 1, 15, 1 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 14, 15, 1 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 1, 15, 14 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 14, 15, 14 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 7, 7, 0 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 8, 7, 0 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 7, 8, 0 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 8, 8, 0 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 7, 7, 15 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 8, 7, 15 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 7, 8, 15 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 8, 8, 15 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 0, 7, 7 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 0, 7, 8 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 0, 8, 7 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 0, 8, 8 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 15, 7, 7 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 15, 7, 8 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 15, 8, 7 }, Block(13));
+ // loaded.back().SetBlock(Chunk::Pos{ 15, 8, 8 }, Block(13));
+ // loaded.back().Invalidate();
+ // loaded.back().CheckUpdate();
+
// orientation testing
// for (int i = 0; i < Block::FACE_COUNT; ++i) {
// for (int j = 0; j < Block::TURN_COUNT; ++j) {
}
}
// add missing new chunks
+ GenerateSurrounding(base);
+}
+
+void ChunkLoader::GenerateSurrounding(const Chunk::Pos &pos) {
const Chunk::Pos offset(load_dist, load_dist, load_dist);
- Generate(base - offset, base + offset);
+ Generate(pos - offset, pos + offset);
}
void ChunkLoader::Update() {