Sort chunks for correct alpha blending (only works for the simple plane water mesh)

2 files changed, 19 insertions, 37 deletions

diff --git a/src/World/World.cpp b/src/World/World.cpp
index 53f92da..de80afe 100644
--- a/src/World/World.cpp
+++ b/src/World/World.cpp
@@ -4,26 +4,20 @@
 namespace MC::World {
 
 std::vector<World::ChunkData*> World::get_visible_chunks(Vector<3> position) {
-    auto finished_chunks = load_finished_chunks_from_queue();
-    auto visible_chunks = get_visible_chunk_indices(position);
-
-    auto updates = visible_chunks;
-    for (auto index : m_visible_chunks) {
-        updates.erase(index);
-    }
-    for (auto index : finished_chunks) {
-        updates.insert(index);
-    }
+    load_finished_chunks_from_queue();
 
-    if (!updates.empty()) {
-        process_chunk_visibility_updates(updates, position);
-        m_visible_chunks = visible_chunks;
-    }
+    auto visible_chunks = get_visible_chunk_indices(position);
 
     std::vector<ChunkData*> chunks{};
     chunks.reserve(visible_chunks.size());
     for (auto index : visible_chunks) {
         auto& data = get(index);
+        if (data.status == ChunkStatus::Empty) {
+            request_generation(index, position.distance(index.middle()));
+            data.status = ChunkStatus::WaitingForGeneration;
+            continue;
+        }
+
         if (data.status == ChunkStatus::NeedsMesh) {
             try_to_create_mesh_for_chunk(data);
         }
@@ -45,44 +39,34 @@ Chunk* World::get_chunk_for_position(Vector<3> position) {
     return nullptr;
 }
 
-void World::process_chunk_visibility_updates(const std::unordered_set<ChunkIndex>& new_chunks, const Vector<3> player) {
-    for (auto new_index: new_chunks) {
-        auto& data = get(new_index);
-        if (data.status == ChunkStatus::Empty) {
-            request_generation(new_index, player.distance(new_index.middle()));
-            data.status = ChunkStatus::WaitingForGeneration;
-        }
-    }
-}
-
-std::unordered_set<ChunkIndex> World::get_visible_chunk_indices(const Vector<3> position) const {
+std::vector<ChunkIndex> World::get_visible_chunk_indices(const Vector<3> position) const {
     I32 center_x = std::round(position.x() / Chunk::Width);
     I32 center_y = std::round(position.z() / Chunk::Width);
 
-    std::unordered_set<ChunkIndex> indices{};
+    std::vector<ChunkIndex> indices{};
     indices.reserve(m_view_distance_radius * m_view_distance_radius * 4);
     auto radius = m_view_distance_radius;
     for (I32 x = -radius; x <= radius; x++) {
         I32 height = std::round(std::sqrt(radius * radius - x * x) + 0.5);
         for (I32 y = -height; y <= height; y++) {
-            indices.emplace(x + center_x, y + center_y);
+            indices.emplace_back(x + center_x, y + center_y);
         }
     }
 
+    auto cmp = [=](const ChunkIndex& a, const ChunkIndex& b) -> bool {
+        return position.distance(a.middle()) > position.distance(b.middle());
+    };
+    std::sort(indices.begin(), indices.end(), cmp);
+
     return indices;
 }
 
-std::unordered_set<ChunkIndex> World::load_finished_chunks_from_queue() {
-    std::unordered_set<ChunkIndex> indices;
+void World::load_finished_chunks_from_queue() {
     auto results = m_queue.done();
     for (auto& [id, res] : results) {
         get(id) = {id, ChunkStatus::NeedsMesh, {res.chunk}};
-        indices.insert(id);
-
         log_chunk_time(res.generation_duration);
     }
-
-    return indices;
 }
 
 void World::request_generation(ChunkIndex index, Real priority) {
diff --git a/src/World/World.hpp b/src/World/World.hpp
index c931ee4..71156f4 100644
--- a/src/World/World.hpp
+++ b/src/World/World.hpp
@@ -37,9 +37,8 @@ public:
 
     Real get_average_chunk_time() const;
 private:
-    std::unordered_set<ChunkIndex> get_visible_chunk_indices(Vector<3> position) const;
-    std::unordered_set<ChunkIndex> load_finished_chunks_from_queue();
-    void process_chunk_visibility_updates(const std::unordered_set<ChunkIndex>& new_chunks, Vector<3> player);
+    std::vector<ChunkIndex> get_visible_chunk_indices(Vector<3> position) const;
+    void load_finished_chunks_from_queue();
     void request_generation(ChunkIndex index, Real priority);
     void try_to_create_mesh_for_chunk(ChunkData& data);
 
@@ -59,7 +58,6 @@ private:
     Generation::Generator m_generator;
 
     std::unordered_map<ChunkIndex, ChunkData> m_chunks;
-    std::unordered_set<ChunkIndex> m_visible_chunks;
 
     struct Statistics {
         UInt chunk_time_sample_count;