From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Wed, 11 Mar 2015 17:07:06 +0000 (+0100)
Subject: split chunk loader from world
X-Git-Url: http://git.localhorst.tv/?a=commitdiff_plain;h=374843f5b3ae60c0d02704a8da5100ac8abe7f1a;p=blank.git

split chunk loader from world
---

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 <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 d996dee..61303aa 100644
--- 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 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<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 4823c47..ccd743d 100644
--- 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;
 
 };