diff --git a/CMakeLists.txt b/CMakeLists.txt index c7787a8..d4c3a46 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -97,19 +97,19 @@ add_executable(${PROJECT_NAME} src/window.cpp ) -#if(CMAKE_BUILD_TYPE STREQUAL "Debug") -# message(STATUS "Building with AddressSanitizer enabled for target: ${PROJECT_NAME}") -# -# target_compile_options(${PROJECT_NAME} PRIVATE -# -fsanitize=address -# -fno-omit-frame-pointer -# -g -# ) -# -# target_link_options(${PROJECT_NAME} PRIVATE -# -fsanitize=address -# ) -#endif() +if(CMAKE_BUILD_TYPE STREQUAL "Debug") + message(STATUS "Building with AddressSanitizer enabled for target: ${PROJECT_NAME}") + + target_compile_options(${PROJECT_NAME} PRIVATE + -fsanitize=address + -fno-omit-frame-pointer + -g + ) + + target_link_options(${PROJECT_NAME} PRIVATE + -fsanitize=address + ) +endif() target_include_directories(${PROJECT_NAME} PUBLIC ${INCLUDE_DIR}) diff --git a/include/Cubed/gameplay/chunk.hpp b/include/Cubed/gameplay/chunk.hpp index 21385da..ab74e79 100644 --- a/include/Cubed/gameplay/chunk.hpp +++ b/include/Cubed/gameplay/chunk.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include @@ -7,12 +8,10 @@ #include class World; - +// if want to use, do init_chunk(), gen_vertex_data() and class Chunk { private: - - bool m_is_gened = false; - bool m_dirty = false; + std::atomic m_dirty {false}; static constexpr int SIZE_X = CHUCK_SIZE; static constexpr int SIZE_Y = WORLD_SIZE_Y; @@ -28,24 +27,33 @@ private: float frequency = 0.01f; float height = 80; + void clear_dirty(); public: Chunk(World& world, ChunkPos chunk_pos); ~Chunk(); Chunk(const Chunk&) = delete; Chunk& operator=(const Chunk&) = delete; - Chunk(Chunk&&) = default; - Chunk& operator=(Chunk&&) = delete; + Chunk(Chunk&&); + Chunk& operator=(Chunk&&); const std::vector& get_chunk_blocks() const; static int get_index(int x, int y, int z); + void init_chunk(); void gen_vertex_data(); + // 0 : (1, 0) + // 1 : (-1, 0) + // 2 : (0, 1) + // 3 : (0, -1) + void gen_vertex_data(const std::vector*>& neighbor_block); + void upload_to_gpu(); + GLuint get_vbo() const; const std::vector& get_vertex_data() const; - void init_chunk(); + bool is_dirty() const; void mark_dirty(); - void clear_dirty(); + void set_chunk_block(int index, unsigned id); }; \ No newline at end of file diff --git a/include/Cubed/gameplay/world.hpp b/include/Cubed/gameplay/world.hpp index eb7a6d1..28ed085 100644 --- a/include/Cubed/gameplay/world.hpp +++ b/include/Cubed/gameplay/world.hpp @@ -1,20 +1,50 @@ #pragma once +#include +#include +#include +#include #include #include #include #include +struct ChunkRenderSnapshot { + GLuint vbo; + size_t vertex_count; + glm::vec3 center; + glm::vec3 half_extents; +}; + + class Player; class World { private: - bool m_need_gen_chunk; + glm::vec3 m_gen_player_pos{0.0f, 0.0f, 0.0f}; std::unordered_map m_chunks; std::unordered_map m_players; std::vector m_planes; - void gen_chunks(); + std::thread m_gen_thread; + std::mutex m_chunks_mutex; + std::mutex m_gen_signal_mutex; + std::mutex m_new_chunk_queue_mutex; + std::mutex m_delete_vbo_mutex; + std::vector m_pending_delete_vbo; + std::condition_variable m_gen_cv; + std::atomic m_gen_running{false}; + std::atomic m_need_gen_chunk{false}; + + std::vector m_dirty_queue; + std::vector m_render_snapshots; + std::vector> m_new_chunk; + std::vector> m_new_chunk_queue; + + void gen_chunks_internal(); + + void start_gen_thread(); + void stop_gen_thread(); public: @@ -31,7 +61,7 @@ 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; + static ChunkPos chunk_pos(int world_x, int world_z); void need_gen(); void render(const glm::mat4& mvp_matrix); @@ -39,5 +69,6 @@ public: void set_block(const glm::ivec3& pos, unsigned id); void update(float delta_time); + void push_delete_vbo(GLuint vbo); }; \ No newline at end of file diff --git a/include/Cubed/gameplay/world_thread_preview.hpp b/include/Cubed/gameplay/world_thread_preview.hpp deleted file mode 100644 index 8e9f49e..0000000 --- a/include/Cubed/gameplay/world_thread_preview.hpp +++ /dev/null @@ -1,68 +0,0 @@ -#pragma once -#include -#include -#include -#include -#include -#include - -#include -#include - -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 m_chunks; - std::unordered_map m_players; - std::vector 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 m_gen_running{false}; - std::atomic m_need_gen_chunk{false}; - - std::vector m_dirty_queue; - std::vector 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& 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); - - -}; \ No newline at end of file diff --git a/lsan.supp b/lsan.supp new file mode 100644 index 0000000..1f9b285 --- /dev/null +++ b/lsan.supp @@ -0,0 +1,7 @@ +leak:libfontconfig.so +leak:libpangoft2 +leak:libpangocairo +leak:libdecor-gtk.so +leak:libgtk-3.so +leak:libwayland-client.so +leak:libglfw.so \ No newline at end of file diff --git a/src/gameplay/chunk.cpp b/src/gameplay/chunk.cpp index 38ac19f..f41447b 100644 --- a/src/gameplay/chunk.cpp +++ b/src/gameplay/chunk.cpp @@ -12,26 +12,45 @@ Chunk::Chunk(World& world, ChunkPos chunk_pos) : Chunk::~Chunk() { if (m_vbo != 0) { - glDeleteBuffers(1, &m_vbo); + m_world.push_delete_vbo(m_vbo); } } +Chunk::Chunk(Chunk&& other) : + m_vbo(other.m_vbo), + m_chunk_pos(std::move(other.m_chunk_pos)), + m_world(other.m_world), + m_blocks(std::move(other.m_blocks)), + m_dirty(other.is_dirty()), + m_vertexs_data(std::move(other.m_vertexs_data)) +{ + other.m_vbo = 0; +} +Chunk& Chunk::operator=(Chunk&& other) { + m_vbo = other.m_vbo; + other.m_vbo = 0; + m_chunk_pos = std::move(other.m_chunk_pos); + m_blocks = std::move(other.m_blocks); + m_dirty = other.is_dirty(); + m_vertexs_data = std::move(other.m_vertexs_data); + return *this; +} const std::vector& Chunk::get_chunk_blocks() const{ return m_blocks; } - int Chunk::get_index(int x, int y, int z) { + CUBED_ASSERT(!(x < 0 || y < 0 || z < 0 || x >= CHUCK_SIZE || y >= WORLD_SIZE_Y || z >= CHUCK_SIZE)); if ((x * WORLD_SIZE_Y + y) * CHUCK_SIZE + z < 0 || (x * WORLD_SIZE_Y + y) * CHUCK_SIZE + z >= CHUCK_SIZE * CHUCK_SIZE * WORLD_SIZE_Y) { Logger::error("block pos x {} y {} z {} range error", x, y, z); CUBED_ASSERT(0); } return (x * WORLD_SIZE_Y + y) * CHUCK_SIZE + z; } - +// this is thread-unsafe! void Chunk::gen_vertex_data() { m_vertexs_data.clear(); @@ -84,18 +103,104 @@ void Chunk::gen_vertex_data() { } } + +} - if (m_vbo == 0) { - glGenBuffers(1, &m_vbo); - +void Chunk::gen_vertex_data(const std::vector*>& neighbor_block) { + 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 < 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; + int id = m_blocks[get_index(x, y, z)]; + // air + if (id == 0) { + continue; + } + for (int face = 0; face < 6; 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) { + + int world_nx = world_x + DIR[face].x; + int world_ny = world_y + DIR[face].y; + int world_nz = world_z + DIR[face].z; + + auto [neighbor_x, neighbor_z] = World::chunk_pos(world_nx, world_nz); + + auto is_block = [&](const std::vector* chunk_blocks){ + if (chunk_blocks == nullptr) { + return false; + } + int x, y, z; + y = world_ny; + x = world_nx - neighbor_x * CHUCK_SIZE; + z = world_nz - neighbor_z * CHUCK_SIZE; + if (x < 0 || y < 0 || z < 0 || x >= CHUCK_SIZE || y >= WORLD_SIZE_Y || z >= CHUCK_SIZE) { + return false; + } + + int idx = Chunk::get_index(x, y, z); + // not init + if (idx >= chunk_blocks->size()) { + Logger::warn("not init"); + return false; + } + auto id = (*chunk_blocks)[idx]; + if (id == 0) { + return false; + } else { + return true; + } + }; + + if (m_chunk_pos.x + 1 == neighbor_x) { + neighbor_soild = is_block(neighbor_block[0]); + } else if (m_chunk_pos.x - 1 == neighbor_x) { + neighbor_soild = is_block(neighbor_block[1]); + } else if (m_chunk_pos.z + 1 == neighbor_z) { + neighbor_soild = is_block(neighbor_block[2]); + } else if (m_chunk_pos.z - 1 == neighbor_z) { + neighbor_soild = is_block(neighbor_block[3]); + } + //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++) { + Vertex vex = { + VERTICES_POS[face][i][0] + (float)world_x * 1.0f, + VERTICES_POS[face][i][1] + (float)world_y * 1.0f, + VERTICES_POS[face][i][2] + (float)world_z * 1.0f, + TEX_COORDS[face][i][0], + TEX_COORDS[face][i][1], + static_cast(id * 6 + face) + + }; + m_vertexs_data.emplace_back(vex); + } + } + } + + } } - glBindBuffer(GL_ARRAY_BUFFER, m_vbo); - glBufferData(GL_ARRAY_BUFFER, m_vertexs_data.size() * sizeof(Vertex), m_vertexs_data.data(), GL_DYNAMIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER, 0); - - - } GLuint Chunk::get_vbo() const{ @@ -135,12 +240,26 @@ void Chunk::init_chunk() { } } - m_is_gened = true; + mark_dirty(); } +void Chunk::upload_to_gpu() { + + CUBED_ASSERT(is_dirty()); + if (m_vbo == 0) { + glGenBuffers(1, &m_vbo); + } + glBindBuffer(GL_ARRAY_BUFFER, m_vbo); + glBufferData(GL_ARRAY_BUFFER, m_vertexs_data.size() * sizeof(Vertex), m_vertexs_data.data(), GL_DYNAMIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); + // after fininshed it, can use + clear_dirty(); + +} + bool Chunk::is_dirty() const{ - return m_dirty; + return m_dirty.load(); } void Chunk::mark_dirty() { diff --git a/src/gameplay/world.cpp b/src/gameplay/world.cpp index a3a65eb..7c9181b 100644 --- a/src/gameplay/world.cpp +++ b/src/gameplay/world.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include #include #include @@ -12,7 +12,15 @@ World::World() { } World::~World() { - + stop_gen_thread(); + m_chunks.clear(); + { + std::lock_guard lk(m_delete_vbo_mutex); + for (auto x : m_pending_delete_vbo) { + glDeleteBuffers(1, &x); + } + m_pending_delete_vbo.clear(); + } } bool World::can_move(const AABB& player_box) const{ @@ -104,6 +112,7 @@ void World::init_world() { auto& [chunk_pos, chunk] = chunk_map; chunk.gen_vertex_data(); + chunk.upload_to_gpu(); } auto t2 = std::chrono::system_clock::now(); @@ -112,15 +121,18 @@ void World::init_world() { // 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& chunk_map : m_chunks) { - const auto& [pos, chunk] = chunk_map; - glm::vec3 center = glm::vec3(static_cast(pos.x * CHUCK_SIZE) + static_cast(CHUCK_SIZE / 2), static_cast(WORLD_SIZE_Y/ 2), static_cast(pos.z * CHUCK_SIZE) + static_cast(CHUCK_SIZE / 2)); - if (is_aabb_in_frustum(center, glm::vec3(static_cast(CHUCK_SIZE / 2), static_cast(WORLD_SIZE_Y / 2), static_cast(CHUCK_SIZE / 2)))) { - glBindBuffer(GL_ARRAY_BUFFER, chunk.get_vbo()); + + 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)); @@ -129,7 +141,7 @@ void World::render(const glm::mat4& mvp_matrix) { glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); - glDrawArrays(GL_TRIANGLES, 0, chunk.get_vertex_data().size()); + glDrawArrays(GL_TRIANGLES, 0, snapshot.vertex_count); glBindBuffer(GL_ARRAY_BUFFER, 0); } @@ -139,7 +151,7 @@ void World::render(const glm::mat4& mvp_matrix) { } -ChunkPos World::chunk_pos(int world_x, int world_z) const{ +ChunkPos World::chunk_pos(int world_x, int world_z) { int chunk_x, chunk_z; if (world_x < 0) { chunk_x = (world_x + 1) / CHUCK_SIZE - 1; @@ -156,9 +168,9 @@ ChunkPos World::chunk_pos(int world_x, int world_z) const{ return {chunk_x, chunk_z}; } -void World::gen_chunks() { - const auto& player = get_player("TestPlayer"); - const auto& player_pos = player.get_player_pos(); +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); @@ -173,20 +185,22 @@ void World::gen_chunks() { } } CUBED_ASSERT_MSG(!cur_chunks.empty(), "cur chunks is empty!!"); - - 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; + std::vector> 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()) { - m_chunks.emplace(pos, Chunk(*this, pos)); - pre_gen_chunks.push_back(pos); + for (auto pos: cur_chunks) { + auto it = m_chunks.find(pos); + if (it == m_chunks.end()) { + pre_gen_chunks.push_back(pos); + } } } @@ -194,27 +208,94 @@ void World::gen_chunks() { if (pre_gen_chunks.empty()) { return; } + + for (auto& pos : pre_gen_chunks) { + new_chunks.push_back({pos, Chunk(*this, pos)}); + } + static const ChunkPos CHUNK_DIR[] { - {1, 0}, {-1, 0}, {0, -1}, {0, 1} + {1, 0}, {-1, 0}, {0, 1}, {0, -1} }; - for (const auto& pos : pre_gen_chunks) { - auto it = m_chunks.find(pos); - CUBED_ASSERT_MSG(it != m_chunks.end(), "Chunk Don't find"); - //Logger::info("Init Chunk {} {}", pos.x, pos.z); - it->second.init_chunk(); - it->second.mark_dirty(); - for (const auto& dir : CHUNK_DIR) { - auto it = m_chunks.find(pos + dir); - if (it != m_chunks.end()) { - it->second.mark_dirty(); + + std::unordered_map neighbor; + + { + std::lock_guard lk(m_chunks_mutex); + for (auto& [pos, chunk] : new_chunks) { + for (const auto& dir : CHUNK_DIR) { + auto it = m_chunks.find(pos + dir); + if (it != m_chunks.end()) { + neighbor.insert({it->first, (it->second)}); + } } } } + std::vector*> neighbor_block(4); + + for (auto& [pos, chunk] : new_chunks) { + + chunk.init_chunk(); + neighbor.insert({pos, chunk}); + + } + + for (auto& [pos, chunk] : new_chunks) { + for (int i = 0; i < 4; i++) { + auto it = neighbor.find(pos + CHUNK_DIR[i]); + if (it != neighbor.end()) { + neighbor_block[i] = &(it->second.get_chunk_blocks()); + } else { + neighbor_block[i] = nullptr; + } + } + chunk.gen_vertex_data(neighbor_block); + } + + { + std::lock_guard lk(m_new_chunk_queue_mutex); + for (auto& x : new_chunks) { + m_new_chunk_queue.emplace_back(std::move(x)); + } + + } + +} + +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 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) { @@ -254,13 +335,11 @@ int World::get_block(const glm::ivec3& block_pos) const { 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; @@ -279,11 +358,11 @@ bool World::is_block(const glm::ivec3& block_pos) const{ 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}); @@ -323,17 +402,55 @@ void World::set_block(const glm::ivec3& block_pos, unsigned id) { void World::update(float delta_time) { for (auto& player : m_players) { player.second.update(delta_time); + } + { + std::lock_guard lk(m_delete_vbo_mutex); + for (auto x : m_pending_delete_vbo) { + glDeleteBuffers(1, &x); + } + m_pending_delete_vbo.clear(); } - if (m_need_gen_chunk) { - gen_chunks(); - m_need_gen_chunk = false; + { + std::scoped_lock lk(m_chunks_mutex, m_new_chunk_queue_mutex); + m_new_chunk.clear(); + for (auto& x : m_new_chunk_queue) { + m_new_chunk.emplace_back(std::move(x)); + } + m_new_chunk_queue.clear(); } - + + for (auto& x : m_new_chunk) { + x.second.upload_to_gpu(); + } + // unified compute vertex data before rendering - for (auto& [key, chunk] : m_chunks) { - if (chunk.is_dirty()) { - chunk.gen_vertex_data(); - chunk.clear_dirty(); + { + std::lock_guard lk(m_chunks_mutex); + for (auto& x : m_new_chunk) { + m_chunks.insert_or_assign(x.first, std::move(x.second)); + } + m_render_snapshots.clear(); + for (auto& [pos, chunk] : m_chunks) { + if (chunk.is_dirty()) { + // the curial fator influence + chunk.gen_vertex_data(); + chunk.upload_to_gpu(); + } + if (!chunk.is_dirty()) { + m_render_snapshots.push_back({ + chunk.get_vbo(), + chunk.get_vertex_data().size(), + glm::vec3(static_cast(pos.x * CHUCK_SIZE) + static_cast(CHUCK_SIZE / 2), static_cast(WORLD_SIZE_Y/ 2), static_cast(pos.z * CHUCK_SIZE) + static_cast(CHUCK_SIZE / 2)), + glm::vec3(static_cast(CHUCK_SIZE / 2), static_cast(WORLD_SIZE_Y / 2), static_cast(CHUCK_SIZE / 2)) + } + ); + } + } } +} + +void World::push_delete_vbo(GLuint vbo) { + std::lock_guard lk(m_delete_vbo_mutex); + m_pending_delete_vbo.push_back(vbo); } \ No newline at end of file diff --git a/src/gameplay/world_thread_preview.cpp b/src/gameplay/world_thread_preview.cpp deleted file mode 100644 index e244b81..0000000 --- a/src/gameplay/world_thread_preview.cpp +++ /dev/null @@ -1,392 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#include - -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 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& World::get_look_block_pos(const std::string& name) const{ - static std::optional 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(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 cur_chunks; - std::vector 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> 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 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(pos.x * CHUCK_SIZE) + static_cast(CHUCK_SIZE / 2), static_cast(WORLD_SIZE_Y/ 2), static_cast(pos.z * CHUCK_SIZE) + static_cast(CHUCK_SIZE / 2)), - glm::vec3(static_cast(CHUCK_SIZE / 2), static_cast(WORLD_SIZE_Y / 2), static_cast(CHUCK_SIZE / 2)) - }); - } - } -} \ No newline at end of file diff --git a/src/window.cpp b/src/window.cpp index a98ebd5..55ca345 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -11,7 +11,11 @@ Window::Window(Renderer& renderer) : } Window::~Window() { - glfwDestroyWindow(m_window); + if (m_window) { + glfwDestroyWindow(m_window); + m_window = nullptr; + } + glfwTerminate(); }