X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fworld%2Fchunk.cpp;h=11c9d36bdaedee1682725db27c31d3341b89b305;hb=dbfcb12348b80e2582f710acb1e4ed0011889ba2;hp=ef3c5fc869d80acb94d4ec054462ce2d85c9cc64;hpb=46b18a88fdda816f3c2c547aba68b0a5ea7970f7;p=blank.git diff --git a/src/world/chunk.cpp b/src/world/chunk.cpp index ef3c5fc..11c9d36 100644 --- a/src/world/chunk.cpp +++ b/src/world/chunk.cpp @@ -4,10 +4,11 @@ #include "Generator.hpp" #include "WorldCollision.hpp" +#include "../io/WorldSave.hpp" #include -#include #include +#include #include @@ -24,17 +25,17 @@ Chunk::Chunk(const BlockTypeRegistry &types) noexcept , neighbor{0} , blocks{} , light{0} -, model() , position(0, 0, 0) -, dirty(false) { +, dirty_model(false) +, dirty_save(false) { } Chunk::Chunk(Chunk &&other) noexcept : types(other.types) -, model(std::move(other.model)) , position(other.position) -, dirty(other.dirty) { +, dirty_model(other.dirty_model) +, dirty_save(other.dirty_save) { 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); @@ -45,9 +46,9 @@ Chunk &Chunk::operator =(Chunk &&other) noexcept { 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; + dirty_model = other.dirty_save; + dirty_save = other.dirty_save; return *this; } @@ -65,9 +66,13 @@ struct SetNode { int Get() const noexcept { return chunk->GetLight(pos); } void Set(int level) noexcept { chunk->SetLight(pos, level); } + const BlockType &GetType() const noexcept { return chunk->Type(Chunk::ToIndex(pos)); } + bool HasNext(Block::Face face) noexcept { + const BlockType &type = GetType(); + if (type.block_light && !type.luminosity) return false; const BlockLookup next(chunk, pos, face); - return next && !next.GetType().block_light; + return next; } SetNode GetNext(Block::Face face) noexcept { const BlockLookup next(chunk, pos, face); @@ -144,6 +149,7 @@ void Chunk::SetBlock(int index, const Block &block) noexcept { const BlockType &new_type = Type(block); blocks[index] = block; + Invalidate(); if (&old_type == &new_type) return; @@ -315,7 +321,7 @@ int Chunk::GetLight(int index) const noexcept { return light[index]; } -float Chunk::GetVertexLight(const Pos &pos, const BlockModel::Position &vtx, const Model::Normal &norm) const noexcept { +float Chunk::GetVertexLight(const Pos &pos, const BlockModel::Position &vtx, const EntityModel::Normal &norm) const noexcept { int index = ToIndex(pos); float light = GetLight(index); @@ -420,24 +426,15 @@ bool Chunk::IsSurface(const Pos &pos) const noexcept { } -void Chunk::Draw() noexcept { - if (dirty) { - Update(); - } - model.Draw(); -} - - bool Chunk::Intersection( const Ray &ray, const glm::mat4 &M, - int &blkid, - float &dist, - glm::vec3 &normal -) const noexcept { + WorldCollision &coll +) noexcept { int idx = 0; - blkid = -1; - dist = std::numeric_limits::infinity(); + coll.chunk = this; + coll.block = -1; + coll.depth = std::numeric_limits::infinity(); for (int z = 0; z < depth; ++z) { for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x, ++idx) { @@ -448,20 +445,20 @@ bool Chunk::Intersection( float cur_dist; glm::vec3 cur_norm; if (type.shape->Intersects(ray, M * ToTransform(Pos(x, y, z), idx), cur_dist, cur_norm)) { - if (cur_dist < dist) { - blkid = idx; - dist = cur_dist; - normal = cur_norm; + if (cur_dist < coll.depth) { + coll.block = idx; + coll.depth = cur_dist; + coll.normal = cur_norm; } } } } } - if (blkid < 0) { + if (coll.block < 0) { return false; } else { - normal = glm::vec3(BlockAt(blkid).Transform() * glm::vec4(normal, 0.0f)); + coll.normal = glm::vec3(BlockAt(coll.block).Transform() * glm::vec4(coll.normal, 0.0f)); return true; } } @@ -471,7 +468,7 @@ bool Chunk::Intersection( const glm::mat4 &Mbox, const glm::mat4 &Mchunk, std::vector &col -) const noexcept { +) noexcept { bool any = false; float penetration; glm::vec3 normal; @@ -503,13 +500,7 @@ BlockModel::Buffer buf; } -void Chunk::CheckUpdate() noexcept { - if (dirty) { - Update(); - } -} - -void Chunk::Update() noexcept { +void Chunk::Update(BlockModel &model) noexcept { int vtx_count = 0, idx_count = 0; for (const auto &block : blocks) { const Shape *shape = Type(block).shape; @@ -545,7 +536,7 @@ void Chunk::Update() noexcept { } model.Update(buf); - dirty = false; + ClearModel(); } Block::FaceSet Chunk::Obstructed(const Pos &pos) const noexcept { @@ -635,12 +626,18 @@ BlockLookup::BlockLookup(Chunk *c, const Chunk::Pos &p, Block::Face face) noexce } -ChunkLoader::ChunkLoader(const Config &config, const BlockTypeRegistry ®, const Generator &gen) noexcept +ChunkLoader::ChunkLoader( + const Config &config, + const BlockTypeRegistry ®, + const Generator &gen, + const WorldSave &save +) noexcept : base(0, 0, 0) , reg(reg) , gen(gen) +, save(save) , loaded() -, to_generate() +, to_load() , to_free() , gen_timer(config.gen_limit) , load_dist(config.load_dist) @@ -669,7 +666,7 @@ struct ChunkLess { } -void ChunkLoader::Generate(const Chunk::Pos &from, const Chunk::Pos &to) { +void ChunkLoader::Queue(const Chunk::Pos &from, const Chunk::Pos &to) { for (int z = from.z; z < to.z; ++z) { for (int y = from.y; y < to.y; ++y) { for (int x = from.x; x < to.x; ++x) { @@ -677,7 +674,7 @@ void ChunkLoader::Generate(const Chunk::Pos &from, const Chunk::Pos &to) { if (Known(pos)) { continue; } else if (pos == base) { - Generate(pos); + Load(pos); // light testing // for (int i = 0; i < 16; ++i) { @@ -724,19 +721,23 @@ void ChunkLoader::Generate(const Chunk::Pos &from, const Chunk::Pos &to) { // loaded.back().Invalidate(); // loaded.back().CheckUpdate(); } else { - to_generate.emplace_back(pos); + to_load.emplace_back(pos); } } } } - to_generate.sort(ChunkLess(base)); + to_load.sort(ChunkLess(base)); } -Chunk &ChunkLoader::Generate(const Chunk::Pos &pos) { +Chunk &ChunkLoader::Load(const Chunk::Pos &pos) { loaded.emplace_back(reg); Chunk &chunk = loaded.back(); chunk.Position(pos); - gen(chunk); + if (save.Exists(pos)) { + save.Read(chunk); + } else { + gen(chunk); + } Insert(chunk); return chunk; } @@ -753,6 +754,10 @@ std::list::iterator ChunkLoader::Remove(std::list::iterator chunk) ++next; // unlink neighbors so they won't reference a dead chunk chunk->ClearNeighbors(); + // if it should be saved, do it now + if (chunk->ShouldUpdateSave()) { + save.Write(*chunk); + } // and move it from loaded to free list to_free.splice(to_free.end(), loaded, chunk); return next; @@ -768,7 +773,7 @@ Chunk *ChunkLoader::Loaded(const Chunk::Pos &pos) noexcept { } bool ChunkLoader::Queued(const Chunk::Pos &pos) noexcept { - for (const Chunk::Pos &chunk : to_generate) { + for (const Chunk::Pos &chunk : to_load) { if (chunk == pos) { return true; } @@ -787,14 +792,14 @@ Chunk &ChunkLoader::ForceLoad(const Chunk::Pos &pos) { return *chunk; } - for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end; ++iter) { + for (auto iter(to_load.begin()), end(to_load.end()); iter != end; ++iter) { if (*iter == pos) { - to_generate.erase(iter); + to_load.erase(iter); break; } } - return Generate(pos); + return Load(pos); } bool ChunkLoader::OutOfRange(const Chunk::Pos &pos) const noexcept { @@ -818,40 +823,75 @@ void ChunkLoader::Rebase(const Chunk::Pos &new_base) { } } // abort far away queued chunks - for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end;) { + for (auto iter(to_load.begin()), end(to_load.end()); iter != end;) { if (OutOfRange(*iter)) { - iter = to_generate.erase(iter); + iter = to_load.erase(iter); } else { ++iter; } } // add missing new chunks - GenerateSurrounding(base); + QueueSurrounding(base); } -void ChunkLoader::GenerateSurrounding(const Chunk::Pos &pos) { +void ChunkLoader::QueueSurrounding(const Chunk::Pos &pos) { const Chunk::Pos offset(load_dist, load_dist, load_dist); - Generate(pos - offset, pos + offset); + Queue(pos - offset, pos + offset); } void ChunkLoader::Update(int dt) { - // check if a chunk generation is scheduled for this frame - // and if there's a chunk waiting to be generated + // check if a chunk load is scheduled for this frame + // and if there's chunks waiting to be loaded gen_timer.Update(dt); - if (!gen_timer.Hit() || to_generate.empty()) { - return; + if (gen_timer.Hit()) { + // we may + // load until one of load or generation limits was hit + constexpr int max_load = 10; + constexpr int max_gen = 1; + int loaded = 0; + int generated = 0; + while (!to_load.empty() && loaded < max_load && generated < max_gen) { + if (LoadOne()) { + ++generated; + } else { + ++loaded; + } + } + } + + constexpr int max_save = 10; + int saved = 0; + for (Chunk &chunk : loaded) { + if (chunk.ShouldUpdateSave()) { + save.Write(chunk); + ++saved; + if (saved >= max_save) { + break; + } + } } +} + +void ChunkLoader::LoadN(std::size_t n) { + std::size_t end = std::min(n, ToLoad()); + for (std::size_t i = 0; i < end; ++i) { + LoadOne(); + } +} + +bool ChunkLoader::LoadOne() { + if (to_load.empty()) return false; // take position of next chunk in queue - Chunk::Pos pos(to_generate.front()); - to_generate.pop_front(); + Chunk::Pos pos(to_load.front()); + to_load.pop_front(); // look if the same chunk was already generated and still lingering for (auto iter(to_free.begin()), end(to_free.end()); iter != end; ++iter) { if (iter->Position() == pos) { loaded.splice(loaded.end(), to_free, iter); Insert(loaded.back()); - return; + return false; } } @@ -864,10 +904,17 @@ void ChunkLoader::Update(int dt) { loaded.splice(loaded.end(), to_free, to_free.begin()); } + bool generated = false; Chunk &chunk = loaded.back(); chunk.Position(pos); - gen(chunk); + if (save.Exists(pos)) { + save.Read(chunk); + } else { + gen(chunk); + generated = true; + } Insert(chunk); + return generated; } }