Add chunk generation time statistics

2 files changed, 40 insertions, 13 deletions

diff --git a/src/World/World.cpp b/src/World/World.cpp
index af70766..289d86b 100644
--- a/src/World/World.cpp
+++ b/src/World/World.cpp
@@ -76,16 +76,20 @@ std::unordered_set<ChunkIndex> World::load_finished_chunks_from_queue() {
     std::unordered_set<ChunkIndex> indices;
     auto results = m_queue.done();
     for (auto& [id, res] : results) {
-        get(id) = {id, ChunkStatus::NeedsMesh, {res}};
+        get(id) = {id, ChunkStatus::NeedsMesh, {res.chunk}};
         indices.insert(id);
+
+        log_chunk_time(res.generation_duration);
     }
 
     return indices;
 }
 
 void World::request_generation(ChunkIndex index, float priority) {
-    m_queue.add(index, priority, [=]() {
-        return m_generator.generate(index.x, index.y);
+    m_queue.add(index, priority, [=]() -> GenerationResult {
+        auto start = timestamp();
+        auto chunk = m_generator.generate(index.x, index.y);
+        return {chunk, timestamp() - start};
     });
 }
 
@@ -101,14 +105,13 @@ World::ChunkData& World::get(ChunkIndex index) {
     return entry->second;
 }
 
-void World::try_to_create_mesh_for_chunk(World::ChunkData& data) {
-//    Chunk empty{0, 0};
-//    data.mesh_data = ChunkMeshing::create_mesh_for_chunk(data.chunk.value(), {
-//            empty, empty, empty, empty,
-//    });
-//    data.mesh = GFX::Binder::load(data.mesh_data.value());
-//    data.status = ChunkStatus::Done;
+uint64_t World::timestamp() {
+    auto time = std::chrono::system_clock::now().time_since_epoch();
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(time);
+    return ms.count();
+}
 
+void World::try_to_create_mesh_for_chunk(ChunkData& data) {
     auto index = data.index;
 
     auto north = get({index.x, index.y - 1});
@@ -132,4 +135,13 @@ void World::try_to_create_mesh_for_chunk(World::ChunkData& data) {
     data.status = ChunkStatus::Done;
 }
 
-}
\ No newline at end of file
+void World::log_chunk_time(uint64_t chunk_time_ms) {
+    m_statistics.chunk_time_sample_count++;
+    m_statistics.average_chunk_time_ms += ((float)chunk_time_ms - m_statistics.average_chunk_time_ms) / m_statistics.chunk_time_sample_count;
+}
+
+float World::get_average_chunk_time() {
+    return m_statistics.average_chunk_time_ms;
+}
+
+}
diff --git a/src/World/World.hpp b/src/World/World.hpp
index 03ed517..e6b3cd2 100644
--- a/src/World/World.hpp
+++ b/src/World/World.hpp
@@ -31,23 +31,38 @@ public:
 
     std::vector<ChunkData*> get_visible_chunks(Vector<3> position);
     Chunk* get_chunk_for_position(Vector<3> position);
+
+    float get_average_chunk_time();
 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(std::unordered_set<ChunkIndex>& new_chunks, Vector<3> player);
     void request_generation(ChunkIndex index, float priority);
+    void try_to_create_mesh_for_chunk(ChunkData& data);
+
+    void log_chunk_time(uint64_t chunk_time_ms);
 
     ChunkData& get(ChunkIndex index);
 
+    static uint64_t timestamp();
+
     uint8_t m_view_distance_radius = 13;
 
-    Compute::Queue<Chunk, ChunkIndex> m_queue;
+    struct GenerationResult {
+        Chunk chunk;
+        uint64_t generation_duration;
+    };
+    Compute::Queue<GenerationResult, ChunkIndex> m_queue;
     Generator m_generator;
 
     std::unordered_map<ChunkIndex, ChunkData> m_chunks;
     std::unordered_set<ChunkIndex> m_visible_chunks;
 
-    void try_to_create_mesh_for_chunk(ChunkData& data);
+    struct Statistics {
+        uint chunk_time_sample_count;
+        float average_chunk_time_ms;
+    };
+    Statistics m_statistics{0, 0.0f};
 };
 
 }