Refactor Chunk mesh handling and improve performance

Modifie la méthode `compute_mesh` pour retourner un objet `Geometry` au lieu d'un `std::optional<Geometry>`, simplifiant ainsi le code. Ajoute la méthode `update_mesh` pour mettre à jour le maillage existant et `is_active` pour vérifier l'état des voxels. Réorganise `ChunkManager::update_world_x` pour améliorer la lisibilité et la logique, tout en commentant des appels à `UpdateChunk` pour éviter des opérations inutiles.

Author: MrScriptX

R3DVoxel/VoxelEngine/Chunk.cpp

@@ -167,10 +167,10 @@ void Chunk::DeleteChunk(std::shared_ptr<GameObject> world)
 		world->RemoveMesh(m_mesh_id);
 }
 
-std::optional<Geometry> Chunk::compute_mesh(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map)
+Geometry Chunk::compute_mesh(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map)
 {
-	if (m_active_voxel == false)
-		return {};
+	/*if (m_active_voxel == false)
+		return {};*/
 
 	m_visible_voxel = { true };
 
@@ -192,8 +192,8 @@ std::optional<Geometry> Chunk::compute_mesh(const std::map<ChunkKey, std::unique
 					{
 						// check if face is hidden by other chunk
 						m_visible_voxel[voxel].xneg =
-						    chunk_map.at({ static_cast<int32_t>(m_position.x) - 1, static_cast<int32_t>(m_position.y), static_cast<int32_t>(m_position.z) })
-						        ->GetVoxel(x + Voxel::CHUNK_SIZE - 1, y, z);
+							chunk_map.at({ static_cast<int32_t>(m_position.x) - 1, static_cast<int32_t>(m_position.y), static_cast<int32_t>(m_position.z) })
+								->GetVoxel(x + Voxel::CHUNK_SIZE - 1, y, z);
 					}
 
 					if (x < Voxel::CHUNK_SIZE - 1)
@@ -203,8 +203,8 @@ std::optional<Geometry> Chunk::compute_mesh(const std::map<ChunkKey, std::unique
 					else if (chunk_map.find({ static_cast<int32_t>(m_position.x) + 1, static_cast<int32_t>(m_position.y), static_cast<int32_t>(m_position.z) }) != chunk_map.end())
 					{
 						m_visible_voxel[voxel].xpos =
-						    chunk_map.at({ static_cast<int32_t>(m_position.x) + 1, static_cast<int32_t>(m_position.y), static_cast<int32_t>(m_position.z) })
-						        ->GetVoxel(x - Voxel::CHUNK_SIZE + 1, y, z);
+							chunk_map.at({ static_cast<int32_t>(m_position.x) + 1, static_cast<int32_t>(m_position.y), static_cast<int32_t>(m_position.z) })
+								->GetVoxel(x - Voxel::CHUNK_SIZE + 1, y, z);
 					}
 
 					if (y > 0)
@@ -256,6 +256,11 @@ void Chunk::render_mesh(const Geometry& mesh, GameObject& world, std::shared_ptr
 	world.bindMatToMesh(m_mesh_id, mat);
 }
 
+void Chunk::update_mesh(const Geometry& mesh, GameObject& world)
+{
+	world.UpdateMesh(m_mesh_id, mesh.vertices, mesh.indices);
+}
+
 void Chunk::SetVoxel(const uint32_t x, const uint32_t y, const uint32_t z)
 {
 	m_active_voxel.set(x + y * Voxel::CHUNK_SIZE + z * Voxel::CHUNK_SIZE_SQR, true);
@@ -271,6 +276,11 @@ bool Chunk::GetVoxel(const uint32_t x, const uint32_t y, const uint32_t z) const
 	return m_active_voxel[x + y * Voxel::CHUNK_SIZE + z * Voxel::CHUNK_SIZE_SQR];
 }
 
+bool Chunk::is_active() const
+{
+	return m_active_voxel.any();
+}
+
 glm::vec3 Chunk::GetPosition() const
 {
 	return m_position;

R3DVoxel/VoxelEngine/Chunk.h

@@ -42,15 +42,17 @@ class Chunk
 	void UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, GameObject& world);
 	void DeleteChunk(std::shared_ptr<GameObject> world);
 
-	std::optional<Geometry> compute_mesh(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map);
+	Geometry compute_mesh(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map);
 	void render_mesh(const Geometry& mesh, GameObject& world, std::shared_ptr<Material> mat);
+	void update_mesh(const Geometry& mesh, GameObject& world);
 
 
 
 	void SetVoxel(const uint32_t x, const uint32_t y, const uint32_t z);
 	void SetBlockType(const uint32_t x, const uint32_t y, const uint32_t z, const TBlock type);
 
 	bool GetVoxel(const uint32_t x, const uint32_t y, const uint32_t z) const;
+	bool is_active() const;
 
 	glm::vec3 GetPosition() const;
 	int32_t mesh_id() const;

R3DVoxel/VoxelEngine/ChunkManager.cpp

@@ -337,12 +337,28 @@ void ChunkManager::update_world_x(int32_t create_x, int32_t update_xplus, int32_
 		for (int32_t y = m_render_min.y; y <= m_render_max.y; y++)
 		{
 			// m_chunk_map.at({ create_x, y, z })->BuildChunk(m_chunk_map, mp_world, mp_world_mat);
-			auto mesh = m_chunk_map.at({ create_x, y, z })->compute_mesh(m_chunk_map);
-			if (mesh.has_value())
-				m_chunk_map.at({ create_x, y, z })->render_mesh(mesh.value(), *mp_world, mp_world_mat);
+			Chunk* new_chunk = m_chunk_map.at({ create_x, y, z }).get();
+			if (new_chunk->is_active())
+			{
+				auto mesh = new_chunk->compute_mesh(m_chunk_map);
+				new_chunk->render_mesh(mesh, *mp_world, mp_world_mat);
+			}
 
-			m_chunk_map.at({ update_xplus, y, z })->UpdateChunk(m_chunk_map, *mp_world);
-			m_chunk_map.at({ update_xmin, y, z })->UpdateChunk(m_chunk_map, *mp_world);
+			// m_chunk_map.at({ update_xplus, y, z })->UpdateChunk(m_chunk_map, *mp_world);
+			Chunk* front_chunk = m_chunk_map.at({ update_xplus, y, z }).get();
+			if (front_chunk->is_active() || front_chunk->mesh_id() != -1)
+			{
+				auto mesh = front_chunk->compute_mesh(m_chunk_map);
+				front_chunk->update_mesh(mesh, *mp_world);
+			}
+			
+			// m_chunk_map.at({ update_xmin, y, z })->UpdateChunk(m_chunk_map, *mp_world);
+			Chunk* back_chunk = m_chunk_map.at({ update_xmin, y, z }).get();
+			if (back_chunk->is_active() || back_chunk->mesh_id() != -1)
+			{
+				auto mesh = back_chunk->compute_mesh(m_chunk_map);
+				back_chunk->update_mesh(mesh, *mp_world);
+			}
 		}
 	}
 }