split chunk loader from world

diff --git a/src/app.cpp b/src/app.cpp
index 7ddbbf189180d43dccd577a91e68a057ef1c8f0f..0f1277535367ca060caffbcf018dd4a356630623 100644 (file)
--- 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 fbfc8578ac3a93da8eab354ad1e37fa56ee07c5f..04c64f26738170a98b64345ddfc9712463ce70d5 100644 (file)
--- a/src/chunk.cpp
+++ b/src/chunk.cpp
@@ -1,5 +1,7 @@
 #include "chunk.hpp"
 
+#include "generator.hpp"
+
 #include <limits>
 #include <glm/gtx/transform.hpp>
 
@@ -140,4 +142,145 @@ void Chunk::Update() {
 }
 
 
+ChunkLoader::ChunkLoader(const BlockTypeRegistry &reg, 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 d996deefc23088876598b6fb486c5a43e91591e5..61303aad02280f102c7d3d14a3175e2b8c73a67d 100644 (file)
--- a/src/chunk.hpp
+++ b/src/chunk.hpp
@@ -5,6 +5,7 @@
 #include "geometry.hpp"
 #include "model.hpp"
 
+#include <list>
 #include <vector>
 #include <glm/glm.hpp>
 
@@ -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<Chunk> &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 &reg;
+       const Generator &gen;
+
+       std::list<Chunk> loaded;
+       std::list<Chunk> to_generate;
+       std::list<Chunk> to_free;
+
+       int load_dist;
+       int unload_dist;
+
+};
+
 }
 
 #endif

diff --git a/src/world.cpp b/src/world.cpp
index 03e0ebb0b474ef3bb7d47a490e4bcf8cce7ef67d..f14ac73d37a6cbfd441e85f1deb124ddb3a1743f 100644 (file)
--- 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<float>::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<int> &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 4823c47b0c8c0ec804f62f10c5d83f4e5c2dbd04..ccd743dd4f1321955410ef1e055f5354140bdb16 100644 (file)
--- a/src/world.hpp
+++ b/src/world.hpp
@@ -8,7 +8,6 @@
 #include "shader.hpp"
 #include "shape.hpp"
 
-#include <list>
 #include <glm/glm.hpp>
 
 
@@ -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<Chunk> &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<int> &dir);
+       Chunk &Next(const Chunk &to, const glm::tvec3<int> &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<Chunk> loaded;
-       std::list<Chunk> to_generate;
-       std::list<Chunk> to_free;
 
 };