feat: thread support for world(preview)

include/Cubed/gameplay/chunk.hpp

@@ -13,6 +13,11 @@ private:
 
     bool m_is_gened = false;
     bool m_dirty = false;
+    
+    static constexpr int SIZE_X = CHUCK_SIZE;
+    static constexpr int SIZE_Y = WORLD_SIZE_Y;
+    static constexpr int SIZE_Z = CHUCK_SIZE;
+    
     ChunkPos m_chunk_pos;
     World& m_world;
     // the index is a array of block id
@@ -26,6 +31,10 @@ private:
 public:
     Chunk(World& world, ChunkPos chunk_pos);
     ~Chunk();
+    Chunk(const Chunk&) = delete;
+    Chunk& operator=(const Chunk&) = delete;
+    Chunk(Chunk&&) = default;
+    Chunk& operator=(Chunk&&) = delete;
     const std::vector<uint8_t>& get_chunk_blocks() const;    
     
     static int get_index(int x, int y, int z);

include/Cubed/gameplay/chunk_status.hpp

@@ -3,6 +3,7 @@
 struct ChunkPos {
     int x;
     int z;
+    
     bool operator==(const ChunkPos&) const = default;
     struct Hash {
         std::size_t operator()(const ChunkPos& pos) const{
@@ -24,3 +25,6 @@ struct ChunkPos {
 };
 
 
+
+
+

include/Cubed/gameplay/player.hpp

@@ -4,6 +4,7 @@
 #include <Cubed/AABB.hpp>
 #include <Cubed/config.hpp>
 #include <Cubed/gameplay/block.hpp>
+#include <Cubed/gameplay/chunk_status.hpp>
 #include <Cubed/input.hpp>
 
 #include <optional>
@@ -43,10 +44,14 @@ private:
     glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f);
     glm::vec3 move_distance {0.0f, 0.0f, 0.0f};
     // player is tow block tall, the pos is the lower pos
+    
     glm::vec3 m_player_pos {0.0f, 120.0f, 0.0f};
+    ChunkPos m_player_chunk_pos {0, 0};
+
     glm::vec3 m_front {0, 0, -1};
     glm::vec3 m_right {0, 0, 0};
     glm::vec3 m_size {0.6f, 1.8f, 0.6f};
+
     Gait m_gait = Gait::WALK;
     MoveState m_move_state {};
 
@@ -56,6 +61,7 @@ private:
 
     bool ray_cast(const glm::vec3& start, const glm::vec3& dir, glm::ivec3& block_pos, glm::vec3& normal, float distance = 4.0f);
 
+    void check_player_chunk_transition();
     void update_direction();
     void update_lookup_block();
     void update_move(float delta_time);

include/Cubed/gameplay/world.hpp

@@ -9,23 +9,20 @@ class Player;
 
 class World {
 private:    
-    bool need_gen_chunk = false;    
-
-    BlockRenderData m_block_render_data;
+    bool m_need_gen_chunk;
     std::unordered_map<ChunkPos , Chunk, ChunkPos::Hash> m_chunks;
     std::unordered_map<std::size_t, Player> m_players;
     std::vector<glm::vec4> m_planes;
 
-    std::pair<int, int> chunk_pos(int world_x, int world_z) const;
     void gen_chunks();
 
-
 public:
     
     World();
     ~World();
+
     bool can_move(const AABB& player_box) const;
-    const BlockRenderData& get_block_render_data(int x, int y ,int z);
+    //const BlockRenderData& get_block_render_data(int x, int y ,int z);
     const std::optional<LookBlock>& get_look_block_pos(const std::string& name) const;
     Player& get_player(const std::string& name);
     void init_world();
@@ -34,6 +31,8 @@ public:
     int get_block(const glm::ivec3& block_pos) const;
     bool is_block(const glm::ivec3& block_pos) const;
     
+    ChunkPos chunk_pos(int world_x, int world_z) const;
+
     void need_gen();
     void render(const glm::mat4& mvp_matrix);
     

include/Cubed/gameplay/world_thread_preview.hpp

@@ -0,0 +1,68 @@
+#pragma once
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <optional>
+#include <unordered_map>
+
+#include <Cubed/AABB.hpp>
+#include <Cubed/gameplay/chunk.hpp>
+
+struct ChunkRenderSnapshot {
+    GLuint vbo;
+    size_t vertex_count;
+    glm::vec3 center;
+    glm::vec3 half_extents;
+};
+
+
+class Player;
+
+class World {
+private:    
+    glm::vec3 m_gen_player_pos{0.0f, 0.0f, 0.0f};
+    std::unordered_map<ChunkPos , Chunk, ChunkPos::Hash> m_chunks;
+    std::unordered_map<std::size_t, Player> m_players;
+    std::vector<glm::vec4> m_planes;
+
+    std::thread m_gen_thread;
+    std::mutex m_chunks_mutex;
+    std::mutex m_gen_signal_mutex; ;
+    std::condition_variable m_gen_cv;
+    std::atomic<bool> m_gen_running{false};
+    std::atomic<bool> m_need_gen_chunk{false};
+
+    std::vector<ChunkPos> m_dirty_queue;
+    std::vector<ChunkRenderSnapshot> m_render_snapshots;
+
+    void gen_chunks_internal();
+
+    void start_gen_thread();
+    void stop_gen_thread();
+
+public:
+    
+    World();
+    ~World();
+
+    bool can_move(const AABB& player_box) const;
+    //const BlockRenderData& get_block_render_data(int x, int y ,int z);
+    const std::optional<LookBlock>& get_look_block_pos(const std::string& name) const;
+    Player& get_player(const std::string& name);
+    void init_world();
+    bool is_aabb_in_frustum(const glm::vec3& center, const glm::vec3& half_extents);
+
+    int get_block(const glm::ivec3& block_pos) const;
+    bool is_block(const glm::ivec3& block_pos) const;
+    
+    ChunkPos chunk_pos(int world_x, int world_z) const;
+
+    void need_gen();
+    void render(const glm::mat4& mvp_matrix);
+    
+    void set_block(const glm::ivec3& pos, unsigned id);
+    void update(float delta_time);
+    
+
+};

src/gameplay/chunk.cpp

@@ -11,9 +11,14 @@ Chunk::Chunk(World& world, ChunkPos chunk_pos) :
 }
 
 Chunk::~Chunk() {
-    glDeleteBuffers(1, &m_vbo);
+    if (m_vbo != 0) {
+        glDeleteBuffers(1, &m_vbo);
+    }
+    
 }
 
+
+
 const std::vector<uint8_t>& Chunk::get_chunk_blocks() const{
     return m_blocks;
 }
@@ -30,20 +35,36 @@ int Chunk::get_index(int x, int y, int z) {
 void Chunk::gen_vertex_data() {
     m_vertexs_data.clear();
     
+    static const glm::ivec3 DIR[6] = {
+        {0,0,1},{1,0,0},{0,0,-1},{-1,0,0},{0,1,0},{0,-1,0}
+    };
 
-    for (int x = 0; x < CHUCK_SIZE; x++) {
-        for (int y = 0; y < WORLD_SIZE_Y; y++) {
-            for (int z = 0; z < CHUCK_SIZE; z++) {
+    for (int x = 0; x < SIZE_X; x++) {
+        for (int y = 0; y < SIZE_Y; y++) {
+            for (int z = 0; z < SIZE_Z; z++) {
                 int world_x = x + m_chunk_pos.x * CHUCK_SIZE;
                 int world_z = z + m_chunk_pos.z * CHUCK_SIZE;
                 int world_y = y;
-                const auto& block_render_data = m_world.get_block_render_data(world_x, world_y, world_z);
+                int id = m_blocks[get_index(x, y, z)];
                 // air
-                if (m_blocks[get_index(x, y, z)] == 0) {
+                if (id == 0) {
                     continue;
                 }
                 for (int face = 0; face < 6; face++) {
-                    if (!block_render_data.draw_face[face]) {
+                    int nx = x + DIR[face].x;
+                    int ny = y + DIR[face].y;
+                    int nz = z + DIR[face].z;
+                    bool neighbor_soild = false;
+
+                    if (nx < 0 || nx >= SIZE_X || ny < 0 || ny >= SIZE_Y || nz < 0 || nz>= SIZE_Z) {
+                        neighbor_soild = m_world.is_block(glm::ivec3(world_x, world_y, world_z) + DIR[face]);
+                    } else {
+                        if (m_blocks[get_index(nx, ny, nz)] != 0) {
+                            neighbor_soild = true;
+                        }
+                    }
+
+                    if (neighbor_soild) {
                         continue;
                     }
                     for (int i = 0; i < 6; i++) {
@@ -53,7 +74,7 @@ void Chunk::gen_vertex_data() {
                             VERTICES_POS[face][i][2] + (float)world_z * 1.0f,
                             TEX_COORDS[face][i][0],
                             TEX_COORDS[face][i][1],
-                            static_cast<float>(block_render_data.block_id * 6 + face) 
+                            static_cast<float>(id * 6 + face) 
 
                         };
                         m_vertexs_data.emplace_back(vex);
@@ -70,7 +91,7 @@ void Chunk::gen_vertex_data() {
     }
     
     glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-    glBufferData(GL_ARRAY_BUFFER, m_vertexs_data.size() * sizeof(Vertex), m_vertexs_data.data(), GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, m_vertexs_data.size() * sizeof(Vertex), m_vertexs_data.data(), GL_DYNAMIC_DRAW);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 
     

src/gameplay/player.cpp

@@ -137,6 +137,7 @@ void Player::set_player_pos(const glm::vec3& pos) {
 void Player::update(float delta_time) {
     update_move(delta_time);
     update_lookup_block();
+    check_player_chunk_transition();
 }
 
 void Player::update_player_move_state(int key, int action) {
@@ -223,6 +224,14 @@ void Player::update_front_vec(float offset_x, float offset_y) {
     m_front = glm::normalize(m_front);
 }
 
+void Player::check_player_chunk_transition() {
+    ChunkPos cur_pos = m_world.chunk_pos(m_player_pos.x, m_player_pos.z);
+    if (cur_pos != m_player_chunk_pos) {
+        m_world.need_gen();
+        m_player_chunk_pos = cur_pos;
+    }
+}
+
 void Player::update_direction() {
     m_right = glm::normalize(glm::cross(m_front, glm::vec3(0.0f, 1.0f, 0.0f)));
 

src/gameplay/world.cpp

@@ -17,11 +17,9 @@ World::~World() {
 
 bool World::can_move(const AABB& player_box) const{
 
-    
-
     return true;
 }
-
+/*
 const BlockRenderData& World::get_block_render_data(int world_x, int world_y ,int world_z) {
     auto [chunk_x, chunk_z] = chunk_pos(world_x, world_z);
     //Logger::info("Chunk PosX : {} Chuch PosZ : {}", chunk_x, chunk_z);
@@ -58,7 +56,7 @@ const BlockRenderData& World::get_block_render_data(int world_x, int world_y ,in
 
     return m_block_render_data;
 }
-
+*/
 const std::optional<LookBlock>& World::get_look_block_pos(const std::string& name) const{
     static std::optional<LookBlock> null_look_block = std::nullopt;
     auto it = m_players.find(HASH::str(name));
@@ -141,7 +139,7 @@ void World::render(const glm::mat4& mvp_matrix) {
 
 }
 
-std::pair<int, int> World::chunk_pos(int world_x, int world_z) const{
+ChunkPos World::chunk_pos(int world_x, int world_z) const{
     int chunk_x, chunk_z;
     if (world_x < 0) {
         chunk_x = (world_x + 1) / CHUCK_SIZE - 1;
@@ -191,6 +189,8 @@ void World::gen_chunks() {
             pre_gen_chunks.push_back(pos);
         }
     }
+
+    Logger::info("New Gen Chunks Sum: {}", pre_gen_chunks.size());
     if (pre_gen_chunks.empty()) {
         return;
     }
@@ -214,7 +214,7 @@ void World::gen_chunks() {
 }
 
 void World::need_gen() {
-    need_gen_chunk = true;
+    m_need_gen_chunk = true;
 }
 
 bool World::is_aabb_in_frustum(const glm::vec3& center, const glm::vec3& half_extents) {
@@ -324,9 +324,9 @@ void World::update(float delta_time) {
     for (auto& player : m_players) {
         player.second.update(delta_time);
     }
-    if (need_gen_chunk) {
+    if (m_need_gen_chunk) {
         gen_chunks();
-        need_gen_chunk = false;
+        m_need_gen_chunk = false;
     }
     
     // unified compute vertex data before rendering

src/gameplay/world_thread_preview.cpp

@@ -0,0 +1,392 @@
+#include <Cubed/gameplay/world_thread_preview.hpp>
+#include <Cubed/gameplay/player.hpp>
+#include <Cubed/map_table.hpp>
+#include <Cubed/tools/cubed_assert.hpp>
+#include <Cubed/tools/cubed_hash.hpp>
+#include <Cubed/tools/math_tools.hpp>
+
+#include <unordered_set>
+
+World::World() {
+    
+}
+
+World::~World() {
+    stop_gen_thread();
+}
+
+bool World::can_move(const AABB& player_box) const{
+
+    return true;
+}
+/*
+const BlockRenderData& World::get_block_render_data(int world_x, int world_y ,int world_z) {
+    auto [chunk_x, chunk_z] = chunk_pos(world_x, world_z);
+    //Logger::info("Chunk PosX : {} Chuch PosZ : {}", chunk_x, chunk_z);
+    auto it = m_chunks.find(ChunkPos{chunk_x, chunk_z});
+    CUBED_ASSERT_MSG(it != m_chunks.end(), "Chunk not find");
+    
+    const auto& chunk_blocks = it->second.get_chunk_blocks();
+    int x, y, z;
+    y = world_y;
+    x = world_x - chunk_x * CHUCK_SIZE;
+    z = world_z - chunk_z * CHUCK_SIZE;
+    //BlockRenderData m_block_render_data;
+    // block id
+    m_block_render_data.block_id = chunk_blocks[Chunk::get_index(x, y, z)];
+    if (m_block_render_data.block_id == 0) {
+        return m_block_render_data;
+    }
+    // draw_face
+    m_block_render_data.draw_face.assign(6, true);
+    static const std::vector<glm::ivec3> DIR = {
+        glm::ivec3(0, 0, 1),
+        glm::ivec3(1, 0, 0),
+        glm::ivec3(0 ,0, -1),
+        glm::ivec3(-1, 0, 0),
+        glm::ivec3(0, 1, 0),
+        glm::ivec3(0, -1, 0)
+    };
+    glm::ivec3 world_pos = glm::ivec3(world_x, world_y, world_z);
+    for (int i = 0; i < 6; i++) {
+        if (is_block(world_pos + DIR[i])) {
+            m_block_render_data.draw_face[i] = false;
+        }
+    }
+
+    return m_block_render_data;
+}
+*/
+const std::optional<LookBlock>& World::get_look_block_pos(const std::string& name) const{
+    static std::optional<LookBlock> null_look_block = std::nullopt;
+    auto it = m_players.find(HASH::str(name));
+    if (it == m_players.end()) {
+        Logger::error("Can't find player {}", name);
+        CUBED_ASSERT(0);
+        return null_look_block;
+    }
+
+    return it->second.get_look_block_pos();
+    
+}
+
+Player& World::get_player(const std::string& name){
+    auto it = m_players.find(HASH::str(name));
+    if (it == m_players.end()) {
+        Logger::error("Can't find player {}", name);
+        CUBED_ASSERT(0);
+    }
+    
+    return it->second;
+}
+
+
+void World::init_world() {
+    auto t1 = std::chrono::system_clock::now();
+    for (int s = 0; s < DISTANCE; s++) {
+        for (int t = 0; t < DISTANCE; t++) {
+            int ns = s - DISTANCE / 2;
+            int nt = t - DISTANCE / 2;
+
+            ChunkPos pos{ns, nt};
+
+            m_chunks.emplace(pos, Chunk(*this, pos)); 
+        }
+    }
+
+    for (auto& chunk_map : m_chunks) {
+        auto& [chunk_pos, chunk] = chunk_map;
+        chunk.init_chunk();
+        
+    }
+    // After block gen fininshed
+    for (auto& chunk_map : m_chunks) {
+        auto& [chunk_pos, chunk] = chunk_map;
+
+        chunk.gen_vertex_data();
+        
+    }
+    auto t2 = std::chrono::system_clock::now();
+    auto d = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1);
+    Logger::info("Chunk Block Init Finish, Time Consuming: {}", d);
+    // init players
+    m_players.emplace(HASH::str("TestPlayer"), Player(*this, "TestPlayer"));
+    Logger::info("TestPlayer Create Finish");
+
+    start_gen_thread();
+
+}
+
+void World::render(const glm::mat4& mvp_matrix) {
+    Math::extract_frustum_planes(mvp_matrix, m_planes);
+
+    for (const auto& snapshot : m_render_snapshots) {
+        
+        if (is_aabb_in_frustum(snapshot.center, snapshot.half_extents)) {
+            glBindBuffer(GL_ARRAY_BUFFER, snapshot.vbo);
+            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
+            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, s));
+            glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, layer));
+
+            glEnableVertexAttribArray(0);
+            glEnableVertexAttribArray(1);
+            glEnableVertexAttribArray(2);
+
+            glDrawArrays(GL_TRIANGLES, 0, snapshot.vertex_count);
+            glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+        }
+        
+
+    }
+
+}
+
+ChunkPos World::chunk_pos(int world_x, int world_z) const{
+    int chunk_x, chunk_z;
+    if (world_x < 0) {
+        chunk_x = (world_x + 1) / CHUCK_SIZE - 1;
+    }
+    if (world_x >= 0) {
+        chunk_x = world_x / CHUCK_SIZE;
+    }
+    if (world_z < 0) {
+        chunk_z = (world_z + 1) / CHUCK_SIZE - 1;
+    }
+    if (world_z >= 0) {
+        chunk_z = world_z / CHUCK_SIZE;
+    }
+    return {chunk_x, chunk_z};
+}
+
+void World::gen_chunks_internal() {
+
+    const auto& player_pos = m_gen_player_pos;
+
+    int x = std::floor(player_pos.x);
+    int z = std::floor(player_pos.z);
+    auto [chunk_x, chunk_z] = chunk_pos(x, z);
+    std::unordered_set<ChunkPos, ChunkPos::Hash> cur_chunks;
+    std::vector<ChunkPos> pre_gen_chunks;
+    cur_chunks.reserve(DISTANCE * DISTANCE);
+    int half = DISTANCE / 2;
+    for (int u = chunk_x - half; u <= chunk_x + half; ++u) {
+        for (int v = chunk_z - half; v <= chunk_z + half; ++v) {
+            cur_chunks.emplace(u, v);
+        }
+    }
+    CUBED_ASSERT_MSG(!cur_chunks.empty(), "cur chunks is empty!!");
+    std::vector<std::pair<ChunkPos, Chunk>> new_chunks;
+    {
+        std::lock_guard lk(m_chunks_mutex);
+        for (auto it = m_chunks.begin(); it != m_chunks.end(); ) {
+            if (cur_chunks.find(it->first) == cur_chunks.end()) {
+                it = m_chunks.erase(it);
+            } else {
+                ++it;
+            }
+        }
+
+        for (auto pos: cur_chunks) {
+            auto it = m_chunks.find(pos);
+            if (it == m_chunks.end()) {
+                pre_gen_chunks.push_back(pos);
+            }
+        }
+    }
+
+    Logger::info("New Gen Chunks Sum: {}", pre_gen_chunks.size());
+    if (pre_gen_chunks.empty()) {
+        return;
+    }
+
+    for (auto& pos : pre_gen_chunks) {
+        new_chunks.push_back({pos, Chunk(*this, pos)});
+    }
+
+    for (auto& [pos, chunk] : new_chunks) {
+        chunk.init_chunk();
+    }
+
+
+
+    static const ChunkPos CHUNK_DIR[] {
+        {1, 0}, {-1, 0}, {0, -1}, {0, 1}
+    };
+
+    {
+        std::lock_guard lk(m_chunks_mutex);
+        for (auto& [pos, chunk] : new_chunks) {
+            chunk.mark_dirty();
+            m_chunks.emplace(pos, std::move(chunk));
+            for (const auto& dir : CHUNK_DIR) {
+                auto it = m_chunks.find(pos + dir);
+                if (it != m_chunks.end()) {
+                    it->second.mark_dirty();
+                }
+            }
+        }
+    } 
+}
+
+void World::start_gen_thread() {
+    m_gen_running = true;
+    Logger::info("Gen Thread Started");
+    m_gen_thread = std::thread([this](){
+        while (m_gen_running) {
+            std::unique_lock<std::mutex> lk(m_gen_signal_mutex);
+
+            m_gen_cv.wait(lk, [this](){
+                return m_need_gen_chunk.load() || !m_gen_running;
+            });
+            if (!m_gen_running) {
+                break;
+            }
+            m_need_gen_chunk = false;
+            lk.unlock();
+
+            gen_chunks_internal();
+        }
+    });
+}
+
+void World::stop_gen_thread() {
+    m_gen_running = false;
+    m_gen_cv.notify_all();
+    if (m_gen_thread.joinable()) {
+        m_gen_thread.join();
+    }
+    Logger::info("Gen Thread Stopped");
+}
+
+void World::need_gen() {
+    m_gen_player_pos = get_player("TestPlayer").get_player_pos();
+    m_need_gen_chunk = true;
+    m_gen_cv.notify_one();
+}
+
+bool World::is_aabb_in_frustum(const glm::vec3& center, const glm::vec3& half_extents) {
+    for (const auto& plane : m_planes) {
+        // distance
+        float d = glm::dot(glm::vec3(plane), center) + plane.w;
+        float r = half_extents.x * std::abs(plane.x) +
+                  half_extents.y * std::abs(plane.y) +
+                  half_extents.z * std::abs(plane.z);
+        if (d + r < 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int World::get_block(const glm::ivec3& block_pos) const {
+    auto [chunk_x, chunk_z] = chunk_pos(block_pos.x, block_pos.z);
+
+    auto it = m_chunks.find(ChunkPos{chunk_x, chunk_z});
+
+    if (it == m_chunks.end()) {
+        return 0;
+    }
+
+    const auto& chunk_blocks = it->second.get_chunk_blocks();
+    int x, y, z;
+    y = block_pos.y;
+    x = block_pos.x - chunk_x * CHUCK_SIZE;
+    z = block_pos.z - chunk_z * CHUCK_SIZE;
+    if (x < 0 || y < 0 || z < 0 || x >= CHUCK_SIZE || y >= WORLD_SIZE_Y || z >= CHUCK_SIZE) {
+        return 0;
+    }
+    return chunk_blocks[Chunk::get_index(x, y, z)];
+
+}
+
+bool World::is_block(const glm::ivec3& block_pos) const{
+    auto [chunk_x, chunk_z] = chunk_pos(block_pos.x, block_pos.z);
+    auto it = m_chunks.find(ChunkPos{chunk_x, chunk_z});
+
+    if (it == m_chunks.end()) {
+        return false;
+    }
+    const auto& chunk_blocks = it->second.get_chunk_blocks();
+    int x, y, z;
+    y = block_pos.y;
+    x = block_pos.x - chunk_x * CHUCK_SIZE;
+    z = block_pos.z - chunk_z * CHUCK_SIZE;
+    if (x < 0 || y < 0 || z < 0 || x >= CHUCK_SIZE || y >= WORLD_SIZE_Y || z >= CHUCK_SIZE) {
+        return false;
+    }
+    auto id = chunk_blocks[Chunk::get_index(x, y, z)];
+    if (id == 0) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+void World::set_block(const glm::ivec3& block_pos, unsigned id) {
+
+    
+    int world_x, world_y, world_z;
+    world_x = block_pos.x;
+    world_y = block_pos.y;
+    world_z = block_pos.z;
+    auto [chunk_x, chunk_z] = chunk_pos(world_x, world_z);
+
+    auto it = m_chunks.find(ChunkPos{chunk_x, chunk_z});
+
+    if (it == m_chunks.end()) {
+        return ;
+    }
+
+    int x, y, z;
+    y = world_y;
+    x = world_x - chunk_x * CHUCK_SIZE;
+    z = world_z - chunk_z * CHUCK_SIZE;
+    if (x < 0 || y < 0 || z < 0 || x >= CHUCK_SIZE || y >= WORLD_SIZE_Y || z >= CHUCK_SIZE) {
+        return ;
+    }
+
+    it->second.set_chunk_block(Chunk::get_index(x, y, z), id);
+
+    static const glm::ivec3 NEIGHBOR_DIRS[] = {
+        {1, 0, 0}, {-1, 0, 0}, {0, 0, -1}, {0, 0, 1}
+    };
+
+    for (const auto& dir : NEIGHBOR_DIRS) {
+        glm::ivec3 neighbor = block_pos + dir;
+
+        auto [cx, cz] = chunk_pos(neighbor.x, neighbor.z);
+        auto it = m_chunks.find({cx, cz});
+        if (it != m_chunks.end()) {
+            it->second.mark_dirty();
+
+        }
+    }
+
+
+}
+
+void World::update(float delta_time) {
+    for (auto& player : m_players) {
+        player.second.update(delta_time);
+    }
+    
+    
+    // unified compute vertex data before rendering
+    {   
+        std::lock_guard lk(m_chunks_mutex);
+        m_render_snapshots.clear();
+        for (auto& [pos, chunk] : m_chunks) {
+            if (chunk.is_dirty()) {
+                chunk.gen_vertex_data();
+                chunk.clear_dirty();
+            }
+            m_render_snapshots.push_back({
+                chunk.get_vbo(),
+                chunk.get_vertex_data().size(),
+                glm::vec3(static_cast<float>(pos.x * CHUCK_SIZE) + static_cast<float>(CHUCK_SIZE / 2), static_cast<float>(WORLD_SIZE_Y/ 2), static_cast<float>(pos.z * CHUCK_SIZE) + static_cast<float>(CHUCK_SIZE / 2)),
+                glm::vec3(static_cast<float>(CHUCK_SIZE / 2), static_cast<float>(WORLD_SIZE_Y / 2), static_cast<float>(CHUCK_SIZE / 2))
+            });
+        }
+    }
+}