From 374843f5b3ae60c0d02704a8da5100ac8abe7f1a Mon Sep 17 00:00:00 2001 From: Daniel Karbach Date: Wed, 11 Mar 2015 18:07:06 +0100 Subject: [PATCH] split chunk loader from world --- src/app.cpp | 2 - src/chunk.cpp | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/chunk.hpp | 36 +++++++++++++ src/world.cpp | 134 +++------------------------------------------- src/world.hpp | 16 +----- 5 files changed, 189 insertions(+), 142 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 7ddbbf1..0f12775 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -31,8 +31,6 @@ Application::Application() , place_id(1) { GLContext::EnableVSync(); - world.Generate({ -4, -4, -4 }, { 5, 5, 5}); - hud.Viewport(960, 600); hud.Display(*world.BlockTypes()[place_id]); diff --git a/src/chunk.cpp b/src/chunk.cpp index fbfc857..04c64f2 100644 --- a/src/chunk.cpp +++ b/src/chunk.cpp @@ -1,5 +1,7 @@ #include "chunk.hpp" +#include "generator.hpp" + #include #include @@ -140,4 +142,145 @@ void Chunk::Update() { } +ChunkLoader::ChunkLoader(const BlockTypeRegistry ®, const Generator &gen) +: base(0, 0, 0) +, reg(reg) +, gen(gen) +, loaded() +, to_generate() +, to_free() +, load_dist(4) +, unload_dist(5) { + +} + +namespace { + +struct ChunkLess { + + explicit ChunkLess(const Chunk::Pos &base) + : base(base) { } + + bool operator ()(const Chunk &a, const Chunk &b) const { + Chunk::Pos da(base - a.Position()); + Chunk::Pos db(base - b.Position()); + return + da.x * da.x + da.y * da.y + da.z * da.z < + db.x * db.x + db.y * db.y + db.z * db.z; + } + + Chunk::Pos base; + +}; + +} + +void ChunkLoader::Generate(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) { + Chunk::Pos pos(x, y, z); + if (Known(pos)) { + continue; + } else if (x == 0 && y == 0 && z == 0) { + loaded.emplace_back(reg); + loaded.back().Position(pos); + gen(loaded.back()); + } else { + to_generate.emplace_back(reg); + to_generate.back().Position(pos); + } + } + } + } + to_generate.sort(ChunkLess(base)); +} + +Chunk *ChunkLoader::Loaded(const Chunk::Pos &pos) { + for (Chunk &chunk : loaded) { + if (chunk.Position() == pos) { + return &chunk; + } + } + return nullptr; +} + +Chunk *ChunkLoader::Queued(const Chunk::Pos &pos) { + for (Chunk &chunk : to_generate) { + if (chunk.Position() == pos) { + return &chunk; + } + } + return nullptr; +} + +Chunk *ChunkLoader::Known(const Chunk::Pos &pos) { + Chunk *chunk = Loaded(pos); + if (chunk) return chunk; + + return Queued(pos); +} + +Chunk &ChunkLoader::ForceLoad(const Chunk::Pos &pos) { + Chunk *chunk = Loaded(pos); + if (chunk) { + return *chunk; + } + + chunk = Queued(pos); + if (chunk) { + gen(*chunk); + return *chunk; + } + + loaded.emplace_back(reg); + loaded.back().Position(pos); + gen(loaded.back()); + return loaded.back(); +} + +void ChunkLoader::Rebase(const Chunk::Pos &new_base) { + if (new_base == base) { + return; + } + base = new_base; + + // unload far away chunks + for (auto iter(loaded.begin()), end(loaded.end()); iter != end;) { + if (std::abs(base.x - iter->Position().x) > unload_dist + || std::abs(base.y - iter->Position().y) > unload_dist + || std::abs(base.z - iter->Position().z) > unload_dist) { + auto saved = iter; + ++iter; + to_free.splice(to_free.end(), loaded, saved); + } else { + ++iter; + } + } + // abort far away queued chunks + for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end;) { + if (std::abs(base.x - iter->Position().x) > unload_dist + || std::abs(base.y - iter->Position().y) > unload_dist + || std::abs(base.z - iter->Position().z) > unload_dist) { + iter = to_generate.erase(iter); + } else { + ++iter; + } + } + // add missing new chunks + const Chunk::Pos offset(load_dist, load_dist, load_dist); + Generate(base - offset, base + offset); +} + +void ChunkLoader::Update() { + if (!to_generate.empty()) { + gen(to_generate.front()); + loaded.splice(loaded.end(), to_generate, to_generate.begin()); + } + + if (!to_free.empty()) { + to_free.pop_front(); + } +} + } diff --git a/src/chunk.hpp b/src/chunk.hpp index d996dee..61303aa 100644 --- a/src/chunk.hpp +++ b/src/chunk.hpp @@ -5,6 +5,7 @@ #include "geometry.hpp" #include "model.hpp" +#include #include #include @@ -87,6 +88,41 @@ private: }; + +class Generator; + +class ChunkLoader { + +public: + ChunkLoader(const BlockTypeRegistry &, const Generator &); + + void Generate(const Chunk::Pos &from, const Chunk::Pos &to); + + std::list &Loaded() { return loaded; } + + Chunk *Loaded(const Chunk::Pos &); + Chunk *Queued(const Chunk::Pos &); + Chunk *Known(const Chunk::Pos &); + Chunk &ForceLoad(const Chunk::Pos &); + + void Rebase(const Chunk::Pos &); + void Update(); + +private: + Chunk::Pos base; + + const BlockTypeRegistry ® + const Generator &gen; + + std::list loaded; + std::list to_generate; + std::list to_free; + + int load_dist; + int unload_dist; + +}; + } #endif diff --git a/src/world.cpp b/src/world.cpp index 03e0ebb..f14ac73 100644 --- a/src/world.cpp +++ b/src/world.cpp @@ -12,11 +12,8 @@ World::World() , stairShape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }}, { 0.0f, 0.0f }) , slabShape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.0f, 0.5f }}) , generate(0) -, player() -, player_chunk(0, 0, 0) -, loaded() -, to_generate() -, to_free() { +, chunks(blockType, generate) +, player() { blockType.Add(BlockType{ true, { 1.0f, 1.0f, 1.0f }, &blockShape }); // white block blockType.Add(BlockType{ true, { 1.0f, 1.0f, 1.0f }, &stairShape }); // white stair blockType.Add(BlockType{ true, { 1.0f, 1.0f, 1.0f }, &slabShape }); // white slab @@ -33,43 +30,10 @@ World::World() generate.Solids({ 1, 4, 7, 10 }); player.Position({ 4.0f, 4.0f, 4.0f }); -} - - -namespace { - -bool ChunkLess(const Chunk &a, const Chunk &b) { - return - a.Position().x * a.Position().x + - a.Position().y * a.Position().y + - a.Position().z * a.Position().z < - b.Position().x * b.Position().x + - b.Position().y * b.Position().y + - b.Position().z * b.Position().z; -} + chunks.Generate({ -4, -4, -4 }, { 5, 5, 5}); } -void World::Generate(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) { - Block::Pos pos{float(x), float(y), float(z)}; - if (ChunkAvailable(pos)) { - continue; - } else if (x == 0 && y == 0 && z == 0) { - loaded.emplace_back(blockType); - loaded.back().Position(pos); - generate(loaded.back()); - } else { - to_generate.emplace_back(blockType); - to_generate.back().Position(pos); - } - } - } - } - to_generate.sort(ChunkLess); -} bool World::Intersection( const Ray &ray, @@ -83,7 +47,7 @@ bool World::Intersection( float closest_dist = std::numeric_limits::infinity(); glm::vec3 closest_normal; - for (Chunk &cur_chunk : loaded) { + for (Chunk &cur_chunk : chunks.Loaded()) { int cur_blkid; float cur_dist; glm::vec3 cur_normal; @@ -113,98 +77,16 @@ bool World::Intersection( } -Chunk *World::ChunkLoaded(const Chunk::Pos &pos) { - for (Chunk &chunk : loaded) { - if (chunk.Position() == pos) { - return &chunk; - } - } - return nullptr; -} - -Chunk *World::ChunkQueued(const Chunk::Pos &pos) { - for (Chunk &chunk : to_generate) { - if (chunk.Position() == pos) { - return &chunk; - } - } - return nullptr; -} - -Chunk *World::ChunkAvailable(const Chunk::Pos &pos) { - Chunk *chunk = ChunkLoaded(pos); - if (chunk) return chunk; - - return ChunkQueued(pos); -} - Chunk &World::Next(const Chunk &to, const glm::tvec3 &dir) { const Chunk::Pos tgt_pos = to.Position() + dir; - - Chunk *chunk = ChunkLoaded(tgt_pos); - if (chunk) { - return *chunk; - } - - chunk = ChunkQueued(tgt_pos); - if (chunk) { - generate(*chunk); - return *chunk; - } - - loaded.emplace_back(blockType); - loaded.back().Position(tgt_pos); - generate(loaded.back()); - return loaded.back(); + return chunks.ForceLoad(tgt_pos); } void World::Update(int dt) { player.Update(dt); - - CheckChunkGeneration(); -} - -void World::CheckChunkGeneration() { - if (player.ChunkCoords() != player_chunk) { - player_chunk = player.ChunkCoords(); - - constexpr int max_dist = 8; - // unload far away chunks - for (auto iter(loaded.begin()), end(loaded.end()); iter != end;) { - if (std::abs(player_chunk.x - iter->Position().x) > max_dist - || std::abs(player_chunk.y - iter->Position().y) > max_dist - || std::abs(player_chunk.z - iter->Position().z) > max_dist) { - auto saved = iter; - ++iter; - to_free.splice(to_free.end(), loaded, saved); - } else { - ++iter; - } - } - // abort far away queued chunks - for (auto iter(to_generate.begin()), end(to_generate.end()); iter != end;) { - if (std::abs(player_chunk.x - iter->Position().x) > max_dist - || std::abs(player_chunk.y - iter->Position().y) > max_dist - || std::abs(player_chunk.z - iter->Position().z) > max_dist) { - iter = to_generate.erase(iter); - } else { - ++iter; - } - } - // add missing new chunks - const Chunk::Pos offset(max_dist, max_dist, max_dist); - Generate(player_chunk - offset, player_chunk + offset); - } - - if (!to_generate.empty()) { - generate(to_generate.front()); - loaded.splice(loaded.end(), to_generate, to_generate.begin()); - } - - if (!to_free.empty()) { - to_free.pop_front(); - } + chunks.Rebase(player.ChunkCoords()); + chunks.Update(); } @@ -212,7 +94,7 @@ void World::Render(DirectionalLighting &program) { program.SetLightDirection({ -1.0f, -3.0f, -2.0f }); program.SetView(glm::inverse(player.Transform(player.ChunkCoords()))); - for (Chunk &chunk : LoadedChunks()) { + for (Chunk &chunk : chunks.Loaded()) { glm::mat4 m(chunk.Transform(player.ChunkCoords())); program.SetM(m); glm::mat4 mvp(program.GetVP() * m); diff --git a/src/world.hpp b/src/world.hpp index 4823c47..ccd743d 100644 --- a/src/world.hpp +++ b/src/world.hpp @@ -8,7 +8,6 @@ #include "shader.hpp" #include "shape.hpp" -#include #include @@ -19,8 +18,6 @@ class World { public: World(); - void Generate(const Chunk::Pos &from, const Chunk::Pos &to); - bool Intersection( const Ray &, const glm::mat4 &M, @@ -30,17 +27,12 @@ public: glm::vec3 *normal = nullptr); BlockTypeRegistry &BlockTypes() { return blockType; } - std::list &LoadedChunks() { return loaded; } Entity &Player() { return player; } - Chunk *ChunkLoaded(const Chunk::Pos &); - Chunk *ChunkQueued(const Chunk::Pos &); - Chunk *ChunkAvailable(const Chunk::Pos &); - Chunk &Next(const Chunk &, const glm::tvec3 &dir); + Chunk &Next(const Chunk &to, const glm::tvec3 &dir); void Update(int dt); - void CheckChunkGeneration(); void Render(DirectionalLighting &); @@ -51,13 +43,9 @@ private: CuboidShape slabShape; Generator generate; + ChunkLoader chunks; Entity player; - Chunk::Pos player_chunk; - - std::list loaded; - std::list to_generate; - std::list to_free; }; -- 2.39.2