zhenyan121/Cubed
1
0
Fork 0
mirror of https://github.com/zhenyan121/Cubed.git synced 2026-04-09 21:54:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

perf: optimize chunk generation

Browse Source
This commit is contained in:
zhenyan121
2026-04-06 17:10:36 +08:00
parent 82f0e1deae
commit f37f458b42
8 changed files with 102 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/Cubed/gameplay/block.hpp
View File

@@ -17,9 +17,22 @@ struct Block : public BlockTexture{
};
struct BlockRenderData {
glm::vec3 pos;
std::vector<bool> draw_face;
unsigned block_id;
BlockRenderData() = default;
BlockRenderData(const BlockRenderData&) = default;
BlockRenderData& operator=(const BlockRenderData&) = default;
BlockRenderData(BlockRenderData&& data) :
draw_face(std::move(data.draw_face)),
block_id(data.block_id)
{
}
BlockRenderData& operator=(BlockRenderData&& data) {
draw_face = std::move(data.draw_face);
block_id = data.block_id;
return *this;
}
};
struct LookBlock {

7
include/Cubed/gameplay/chunk.hpp
View File

@@ -10,6 +10,9 @@ class World;
class Chunk {
private:
bool m_is_gened = false;
bool m_dirty = false;
ChunkPos m_chunk_pos;
World& m_world;
// the index is a array of block id
@@ -31,7 +34,9 @@ public:
GLuint get_vbo() const;
const std::vector<Vertex>& 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);
};

10
include/Cubed/gameplay/chunk_status.hpp
View File

@@ -11,6 +11,16 @@ struct ChunkPos {
return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
}
};
ChunkPos operator+(const ChunkPos& pos) const{
return ChunkPos{x + pos.x, z + pos.z};
}
ChunkPos& operator+=(const ChunkPos& pos) {
x += pos.x;
z += pos.z;
return *this;
};
};

2
include/Cubed/gameplay/world.hpp
View File

@@ -16,7 +16,7 @@ private:
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);
std::pair<int, int> chunk_pos(int world_x, int world_z) const;
void gen_chunks();

3
src/app.cpp
View File

@@ -130,7 +130,8 @@ void App::render() {
}
void App::run() {
last_time = glfwGetTime();
while(!glfwWindowShouldClose(m_window.get_glfw_window())) {
update();

25
src/gameplay/chunk.cpp
View File

@@ -29,7 +29,11 @@ int Chunk::get_index(int x, int y, int z) {
void Chunk::gen_vertex_data() {
m_vertexs_data.clear();
glDeleteBuffers(1, &m_vbo);
if (m_vbo != 0) {
glDeleteBuffers(1, &m_vbo);
m_vbo = 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++) {
@@ -68,6 +72,8 @@ void Chunk::gen_vertex_data() {
glBufferData(GL_ARRAY_BUFFER, m_vertexs_data.size() * sizeof(Vertex), m_vertexs_data.data(), GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
GLuint Chunk::get_vbo() const{
@@ -107,14 +113,25 @@ void Chunk::init_chunk() {
}
}
m_is_gened = true;
}
bool Chunk::is_dirty() const{
return m_dirty;
}
void Chunk::mark_dirty() {
m_dirty = true;
}
void Chunk::clear_dirty() {
m_dirty = false;
}
void Chunk::set_chunk_block(int index ,unsigned id) {
m_blocks[index] = id;
glDeleteBuffers(1, &m_vbo);
gen_vertex_data();
mark_dirty();
}

11
src/gameplay/player.cpp
View File

@@ -291,6 +291,10 @@ void Player::update_lookup_block() {
}
void Player::update_move(float delta_time) {
// if frame rate less than 1 frame per second, don't update
if (delta_time > 1.0f) {
return;
}
if (m_gait == Gait::RUN) {
max_speed = RUN_SPEED;
}
@@ -347,10 +351,6 @@ void Player::update_move(float delta_time) {
y_speed += -G * delta_time;
}
move_distance.y = y_speed * delta_time;
// y
update_y_move();
@@ -360,7 +360,8 @@ void Player::update_move(float delta_time) {
update_z_move();
if (m_player_pos.y < -15.0f) {
m_player_pos = glm::vec3(0.0f, 100.0f, 0.0f);
Logger::warn("y is tow low");
m_player_pos += glm::vec3(1.0f, 100.0f, 1.0f);
}
}

172
src/gameplay/world.cpp
View File

@@ -33,6 +33,7 @@ const BlockRenderData& World::get_block_render_data(int world_x, int world_y ,in
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) {
@@ -83,6 +84,7 @@ Player& World::get_player(const std::string& name){
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;
@@ -106,7 +108,9 @@ void World::init_world() {
chunk.gen_vertex_data();
}
Logger::info("Chunk Block Init Finish");
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");
@@ -127,7 +131,7 @@ void World::render(const glm::mat4& mvp_matrix) {
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glDrawArrays(GL_TRIANGLES, 0, chunk.get_vertex_data().size() * 3);
glDrawArrays(GL_TRIANGLES, 0, chunk.get_vertex_data().size());
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
@@ -137,7 +141,7 @@ void World::render(const glm::mat4& mvp_matrix) {
}
std::pair<int, int> World::chunk_pos(int world_x, int world_z) {
std::pair<int, int> 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;
@@ -155,7 +159,6 @@ std::pair<int, int> World::chunk_pos(int world_x, int world_z) {
}
void World::gen_chunks() {
Logger::info("start gen chunks");
const auto& player = get_player("TestPlayer");
const auto& player_pos = player.get_player_pos();
@@ -172,7 +175,6 @@ void World::gen_chunks() {
}
}
CUBED_ASSERT_MSG(!cur_chunks.empty(), "cur chunks is empty!!");
Logger::info("Cur Chunk pos gen finish, size {}", cur_chunks.size());
for (auto it = m_chunks.begin(); it != m_chunks.end(); ) {
if (cur_chunks.find(it->first) == cur_chunks.end()) {
@@ -189,25 +191,26 @@ void World::gen_chunks() {
pre_gen_chunks.push_back(pos);
}
}
Logger::info("start to init new chunk");
if (pre_gen_chunks.empty()) {
return;
}
static const ChunkPos CHUNK_DIR[] {
{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();
}
}
}
// After block gen fininshed
for (auto& chunk_map : m_chunks) {
auto& [chunk_pos, chunk] = chunk_map;
chunk.gen_vertex_data();
}
Logger::info("gen chunks finish");
}
void World::need_gen() {
@@ -228,24 +231,12 @@ bool World::is_aabb_in_frustum(const glm::vec3& center, const glm::vec3& half_ex
return true;
}
bool World::is_block(const glm::ivec3& block_pos) const{
int chunk_x, chunk_z;
int world_x, world_y, world_z;
world_x = block_pos.x;
world_y = block_pos.y;
world_z = block_pos.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;
}
auto [chunk_x, chunk_z] = chunk_pos(world_x, world_z);
auto it = m_chunks.find(ChunkPos{chunk_x, chunk_z});
@@ -271,24 +262,12 @@ bool World::is_block(const glm::ivec3& block_pos) const{
void World::set_block(const glm::ivec3& block_pos, unsigned id) {
int chunk_x, chunk_z;
int world_x, world_y, world_z;
world_x = block_pos.x;
world_y = block_pos.y;
world_z = block_pos.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;
}
auto [chunk_x, chunk_z] = chunk_pos(world_x, world_z);
auto it = m_chunks.find(ChunkPos{chunk_x, chunk_z});
@@ -306,96 +285,21 @@ void World::set_block(const glm::ivec3& block_pos, unsigned id) {
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}
};
int adjacent_chunk_x;
int adjacent_chunk_z;
int adj_world_x;
int adj_world_z;
if (x == 0) {
adj_world_x = world_x - 1;
adj_world_z = world_z;
if (adj_world_x < 0) {
adjacent_chunk_x = (adj_world_x + 1) / CHUCK_SIZE - 1;
}
if (adj_world_x >= 0) {
adjacent_chunk_x = adj_world_x / CHUCK_SIZE;
}
if (adj_world_z < 0) {
adjacent_chunk_z = (adj_world_z + 1) / CHUCK_SIZE - 1;
}
if (adj_world_z >= 0) {
adjacent_chunk_z = adj_world_z / CHUCK_SIZE;
}
auto adjacent = m_chunks.find(ChunkPos{adjacent_chunk_x, adjacent_chunk_z});
if (adjacent != m_chunks.end()) {
adjacent->second.gen_vertex_data();
}
}
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();
if (x == CHUCK_SIZE - 1) {
adj_world_x = world_x + 1;
adj_world_z = world_z;
if (adj_world_x < 0) {
adjacent_chunk_x = (adj_world_x + 1) / CHUCK_SIZE - 1;
}
if (adj_world_x >= 0) {
adjacent_chunk_x = adj_world_x/ CHUCK_SIZE;
}
if (adj_world_z < 0) {
adjacent_chunk_z = (adj_world_z + 1) / CHUCK_SIZE - 1;
}
if (adj_world_z >= 0) {
adjacent_chunk_z = adj_world_z / CHUCK_SIZE;
}
auto adjacent = m_chunks.find(ChunkPos{adjacent_chunk_x, adjacent_chunk_z});
if (adjacent != m_chunks.end()) {
adjacent->second.gen_vertex_data();
}
}
if (z == 0) {
adj_world_x = world_x;
adj_world_z = world_z - 1;
if (adj_world_x < 0) {
adjacent_chunk_x = (adj_world_x + 1) / CHUCK_SIZE - 1;
}
if (adj_world_x >= 0) {
adjacent_chunk_x = adj_world_x / CHUCK_SIZE;
}
if (adj_world_z < 0) {
adjacent_chunk_z = (adj_world_z + 1) / CHUCK_SIZE - 1;
}
if (adj_world_z >= 0) {
adjacent_chunk_z = adj_world_z / CHUCK_SIZE;
}
auto adjacent = m_chunks.find(ChunkPos{adjacent_chunk_x, adjacent_chunk_z});
if (adjacent != m_chunks.end()) {
adjacent->second.gen_vertex_data();
}
}
if (z == CHUCK_SIZE - 1) {
adj_world_x = world_x;
adj_world_z = world_z + 1;
if (adj_world_x < 0) {
adjacent_chunk_x = (adj_world_x + 1) / CHUCK_SIZE - 1;
}
if (adj_world_x >= 0) {
adjacent_chunk_x = adj_world_x/ CHUCK_SIZE;
}
if (adj_world_z < 0) {
adjacent_chunk_z = (adj_world_z + 1) / CHUCK_SIZE - 1;
}
if (adj_world_z >= 0) {
adjacent_chunk_z = adj_world_z / CHUCK_SIZE;
}
auto adjacent = m_chunks.find(ChunkPos{adjacent_chunk_x, adjacent_chunk_z});
if (adjacent != m_chunks.end()) {
adjacent->second.gen_vertex_data();
}
}
}
@@ -407,4 +311,12 @@ void World::update(float delta_time) {
gen_chunks();
need_gen_chunk = false;
}
// unified compute vertex data before rendering
for (auto& [key, chunk] : m_chunks) {
if (chunk.is_dirty()) {
chunk.gen_vertex_data();
chunk.clear_dirty();
}
}
}