Refactor Chunk and ChunkManager method signatures

Dan Liebault · Dan Liebault · commit b7701923e4b0 · 2025-04-02T15:07:44.000+02:00
Modifications des signatures des méthodes `UpdateChunk` pour utiliser des références d'objet `GameObject` au lieu de pointeurs partagés, améliorant ainsi la gestion de la mémoire. Les méthodes `GetVoxel` et `GetPosition` ont été rendues constantes pour permettre leur utilisation sur des instances constantes. Ajout d'une méthode `mesh_id` pour récupérer l'identifiant du maillage. La méthode `UpdateWorld` dans `ChunkManager` retourne maintenant un booléen pour indiquer si une mise à jour de la scène est nécessaire, simplifiant ainsi l'interface. Ajustements pour assurer la cohérence des appels de méthode.
diff --git a/R3DVoxel/VoxelEngine/Chunk.cpp b/R3DVoxel/VoxelEngine/Chunk.cpp
@@ -85,7 +85,7 @@ void Chunk::BuildChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_m
 	world->bindMatToMesh(m_mesh_id, mat);
 }
 
-void Chunk::UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, std::shared_ptr<GameObject> world)
+void Chunk::UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, GameObject& world)
 {
 	// mesh should be updated only m_mesh_id != -1 otherwise, it should be built
 	if (m_active_voxel == false || m_mesh_id == -1)
@@ -158,7 +158,7 @@ void Chunk::UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_
 		}
 	}
 
-	world->UpdateMesh(m_mesh_id, mesh.vertices, mesh.indices);
+	world.UpdateMesh(m_mesh_id, mesh.vertices, mesh.indices);
 }
 
 void Chunk::DeleteChunk(std::shared_ptr<GameObject> world)
@@ -177,16 +177,21 @@ void Chunk::SetBlockType(const uint32_t x, const uint32_t y, const uint32_t z, c
 	m_blocktypes.at(x + y * Voxel::CHUNK_SIZE + z * Voxel::CHUNK_SIZE_SQR) = type;
 }
 
-bool Chunk::GetVoxel(const uint32_t x, const uint32_t y, const uint32_t z)
+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];
 }
 
-glm::vec3 Chunk::GetPosition()
+glm::vec3 Chunk::GetPosition() const
 {
 	return m_position;
 }
 
+int32_t Chunk::mesh_id() const
+{
+	return m_mesh_id;
+}
+
 void Chunk::CreateCube(Geometry& mesh, uint32_t x, uint32_t y, uint32_t z)
 {
 	//vertex
diff --git a/R3DVoxel/VoxelEngine/Chunk.h b/R3DVoxel/VoxelEngine/Chunk.h
@@ -39,15 +39,16 @@ class Chunk
 	Chunk(const int32_t posx, const int32_t posy, const int32_t posz);
 
 	void BuildChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, std::shared_ptr<GameObject> world, std::shared_ptr<Material> mat);
-	void UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, std::shared_ptr<GameObject> world);
+	void UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, GameObject& world);
 	void DeleteChunk(std::shared_ptr<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);
+	bool GetVoxel(const uint32_t x, const uint32_t y, const uint32_t z) const;
 
-	glm::vec3 GetPosition();
+	glm::vec3 GetPosition() const;
+	int32_t mesh_id() const;
 
 private:
 	void CreateCube(Geometry& mesh, uint32_t x, uint32_t y, uint32_t z);
diff --git a/R3DVoxel/VoxelEngine/ChunkManager.cpp b/R3DVoxel/VoxelEngine/ChunkManager.cpp
@@ -64,16 +64,16 @@ void ChunkManager::CreateWorld()
 	}
 }
 
-void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<Camera> p_camera)
+bool ChunkManager::UpdateWorld(const Camera& camera)
 {
 	bool scene_x_need_update = false;
 
 	int32_t create_x = -1;
 	int32_t update_xplus = -1;
 	int32_t update_xmin = -1;
-	if (p_camera->GetPosition().x > m_render_position.x + Voxel::CHUNK_SIZE)
+	if (camera.GetPosition().x > m_render_position.x + Voxel::CHUNK_SIZE)
 	{
-		m_render_position.x = p_camera->GetPosition().x;
+		m_render_position.x = camera.GetPosition().x;
 
 		m_render_max.x = m_render_max.x + 1;
 
@@ -93,9 +93,9 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C
 		update_xmin = m_render_min.x;
 		scene_x_need_update = true;
 	}
-	else if (p_camera->GetPosition().x < m_render_position.x - Voxel::CHUNK_SIZE)
+	else if (camera.GetPosition().x < m_render_position.x - Voxel::CHUNK_SIZE)
 	{
-		m_render_position.x = p_camera->GetPosition().x;
+		m_render_position.x = camera.GetPosition().x;
 
 		m_render_min.x = m_render_min.x - 1;
 
@@ -121,9 +121,9 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C
 	int32_t create_z = -1;
 	int32_t update_zplus = -1;
 	int32_t update_zmin = -1;
-	if (p_camera->GetPosition().z > m_render_position.z + Voxel::CHUNK_SIZE)
+	if (camera.GetPosition().z > m_render_position.z + Voxel::CHUNK_SIZE)
 	{
-		m_render_position.z = p_camera->GetPosition().z;
+		m_render_position.z = camera.GetPosition().z;
 
 		m_render_max.z = m_render_max.z + 1;
 
@@ -143,9 +143,9 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C
 		update_zmin = m_render_min.z;
 		scene_z_need_update = true;
 	}
-	else if (p_camera->GetPosition().z < m_render_position.z - Voxel::CHUNK_SIZE)
+	else if (camera.GetPosition().z < m_render_position.z - Voxel::CHUNK_SIZE)
 	{
-		m_render_position.z = p_camera->GetPosition().z;
+		m_render_position.z = camera.GetPosition().z;
 
 		m_render_min.z = m_render_min.z - 1;
 
@@ -173,8 +173,8 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C
 			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);
-				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);
+				m_chunk_map.at({ update_xmin, y, z })->UpdateChunk(m_chunk_map, *mp_world);
 			}
 		}
 	}
@@ -186,18 +186,17 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C
 			for (int32_t y = m_render_min.y; y <= m_render_max.y; y++)
 			{
 				m_chunk_map.at({ x, y, create_z })->BuildChunk(m_chunk_map, mp_world, mp_world_mat);
-				m_chunk_map.at({ x, y, update_zplus })->UpdateChunk(m_chunk_map, mp_world);
-				m_chunk_map.at({ x, y, update_zmin })->UpdateChunk(m_chunk_map, mp_world);
+				m_chunk_map.at({ x, y, update_zplus })->UpdateChunk(m_chunk_map, *mp_world);
+				m_chunk_map.at({ x, y, update_zmin })->UpdateChunk(m_chunk_map, *mp_world);
 			}
 		}
 	}
 
-	if (scene_x_need_update || scene_z_need_update)
-		p_scene->ToUpdate();
-
 	Watcher::WatchPosition("render position", m_render_position);
 	Watcher::WatchPosition("render max", m_render_max);
 	Watcher::WatchPosition("render min", m_render_min);
+
+	return scene_x_need_update || scene_z_need_update;
 }
 
 void ChunkManager::CreateNewChunk(int32_t x, int32_t y, int32_t z)
diff --git a/R3DVoxel/VoxelEngine/ChunkManager.h b/R3DVoxel/VoxelEngine/ChunkManager.h
@@ -16,7 +16,7 @@ class ChunkManager
 	~ChunkManager() = default;
 
 	void CreateWorld();
-	void UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<Camera> p_camera);
+	bool UpdateWorld(const Camera& camera);
 
 	void CreateNewChunk(int32_t x, int32_t y, int32_t z);
 	void DestroyChunk(const int32_t x, const int32_t y, const int32_t z);

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ void Chunk::BuildChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_m`
`85`	`85`	`world->bindMatToMesh(m_mesh_id, mat);`
`86`	`86`	`}`
`87`	`87`
`88`		`-void Chunk::UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, std::shared_ptr<GameObject> world)`
	`88`	`+void Chunk::UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_map, GameObject& world)`
`89`	`89`	`{`
`90`	`90`	`// mesh should be updated only m_mesh_id != -1 otherwise, it should be built`
`91`	`91`	`if (m_active_voxel == false \|\| m_mesh_id == -1)`
`@@ -158,7 +158,7 @@ void Chunk::UpdateChunk(const std::map<ChunkKey, std::unique_ptr<Chunk>>& chunk_`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`- world->UpdateMesh(m_mesh_id, mesh.vertices, mesh.indices);`
	`161`	`+ world.UpdateMesh(m_mesh_id, mesh.vertices, mesh.indices);`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`void Chunk::DeleteChunk(std::shared_ptr<GameObject> world)`
`@@ -177,16 +177,21 @@ void Chunk::SetBlockType(const uint32_t x, const uint32_t y, const uint32_t z, c`
`177`	`177`	`m_blocktypes.at(x + y * Voxel::CHUNK_SIZE + z * Voxel::CHUNK_SIZE_SQR) = type;`
`178`	`178`	`}`
`179`	`179`
`180`		`-bool Chunk::GetVoxel(const uint32_t x, const uint32_t y, const uint32_t z)`
	`180`	`+bool Chunk::GetVoxel(const uint32_t x, const uint32_t y, const uint32_t z) const`
`181`	`181`	`{`
`182`	`182`	`return m_active_voxel[x + y * Voxel::CHUNK_SIZE + z * Voxel::CHUNK_SIZE_SQR];`
`183`	`183`	`}`
`184`	`184`
`185`		`-glm::vec3 Chunk::GetPosition()`
	`185`	`+glm::vec3 Chunk::GetPosition() const`
`186`	`186`	`{`
`187`	`187`	`return m_position;`
`188`	`188`	`}`
`189`	`189`
	`190`	`+int32_t Chunk::mesh_id() const`
	`191`	`+{`
	`192`	`+ return m_mesh_id;`
	`193`	`+}`
	`194`	`+`
`190`	`195`	`void Chunk::CreateCube(Geometry& mesh, uint32_t x, uint32_t y, uint32_t z)`
`191`	`196`	`{`
`192`	`197`	`//vertex`
Original file line number	Diff line number	Diff line change
`@@ -64,16 +64,16 @@ void ChunkManager::CreateWorld()`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`		`-void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<Camera> p_camera)`
	`67`	`+bool ChunkManager::UpdateWorld(const Camera& camera)`
`68`	`68`	`{`
`69`	`69`	`bool scene_x_need_update = false;`
`70`	`70`
`71`	`71`	`int32_t create_x = -1;`
`72`	`72`	`int32_t update_xplus = -1;`
`73`	`73`	`int32_t update_xmin = -1;`
`74`		`- if (p_camera->GetPosition().x > m_render_position.x + Voxel::CHUNK_SIZE)`
	`74`	`+ if (camera.GetPosition().x > m_render_position.x + Voxel::CHUNK_SIZE)`
`75`	`75`	`{`
`76`		`- m_render_position.x = p_camera->GetPosition().x;`
	`76`	`+ m_render_position.x = camera.GetPosition().x;`
`77`	`77`
`78`	`78`	`m_render_max.x = m_render_max.x + 1;`
`79`	`79`
`@@ -93,9 +93,9 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C`
`93`	`93`	`update_xmin = m_render_min.x;`
`94`	`94`	`scene_x_need_update = true;`
`95`	`95`	`}`
`96`		`- else if (p_camera->GetPosition().x < m_render_position.x - Voxel::CHUNK_SIZE)`
	`96`	`+ else if (camera.GetPosition().x < m_render_position.x - Voxel::CHUNK_SIZE)`
`97`	`97`	`{`
`98`		`- m_render_position.x = p_camera->GetPosition().x;`
	`98`	`+ m_render_position.x = camera.GetPosition().x;`
`99`	`99`
`100`	`100`	`m_render_min.x = m_render_min.x - 1;`
`101`	`101`
`@@ -121,9 +121,9 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C`
`121`	`121`	`int32_t create_z = -1;`
`122`	`122`	`int32_t update_zplus = -1;`
`123`	`123`	`int32_t update_zmin = -1;`
`124`		`- if (p_camera->GetPosition().z > m_render_position.z + Voxel::CHUNK_SIZE)`
	`124`	`+ if (camera.GetPosition().z > m_render_position.z + Voxel::CHUNK_SIZE)`
`125`	`125`	`{`
`126`		`- m_render_position.z = p_camera->GetPosition().z;`
	`126`	`+ m_render_position.z = camera.GetPosition().z;`
`127`	`127`
`128`	`128`	`m_render_max.z = m_render_max.z + 1;`
`129`	`129`
`@@ -143,9 +143,9 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C`
`143`	`143`	`update_zmin = m_render_min.z;`
`144`	`144`	`scene_z_need_update = true;`
`145`	`145`	`}`
`146`		`- else if (p_camera->GetPosition().z < m_render_position.z - Voxel::CHUNK_SIZE)`
	`146`	`+ else if (camera.GetPosition().z < m_render_position.z - Voxel::CHUNK_SIZE)`
`147`	`147`	`{`
`148`		`- m_render_position.z = p_camera->GetPosition().z;`
	`148`	`+ m_render_position.z = camera.GetPosition().z;`
`149`	`149`
`150`	`150`	`m_render_min.z = m_render_min.z - 1;`
`151`	`151`
`@@ -173,8 +173,8 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C`
`173`	`173`	`for (int32_t y = m_render_min.y; y <= m_render_max.y; y++)`
`174`	`174`	`{`
`175`	`175`	`m_chunk_map.at({ create_x, y, z })->BuildChunk(m_chunk_map, mp_world, mp_world_mat);`
`176`		`- m_chunk_map.at({ update_xplus, y, z })->UpdateChunk(m_chunk_map, mp_world);`
`177`		`- m_chunk_map.at({ update_xmin, y, z })->UpdateChunk(m_chunk_map, mp_world);`
	`176`	`+ m_chunk_map.at({ update_xplus, y, z })->UpdateChunk(m_chunk_map, *mp_world);`
	`177`	`+ m_chunk_map.at({ update_xmin, y, z })->UpdateChunk(m_chunk_map, *mp_world);`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`	`}`
`@@ -186,18 +186,17 @@ void ChunkManager::UpdateWorld(std::shared_ptr<Scene> p_scene, std::shared_ptr<C`
`186`	`186`	`for (int32_t y = m_render_min.y; y <= m_render_max.y; y++)`
`187`	`187`	`{`
`188`	`188`	`m_chunk_map.at({ x, y, create_z })->BuildChunk(m_chunk_map, mp_world, mp_world_mat);`
`189`		`- m_chunk_map.at({ x, y, update_zplus })->UpdateChunk(m_chunk_map, mp_world);`
`190`		`- m_chunk_map.at({ x, y, update_zmin })->UpdateChunk(m_chunk_map, mp_world);`
	`189`	`+ m_chunk_map.at({ x, y, update_zplus })->UpdateChunk(m_chunk_map, *mp_world);`
	`190`	`+ m_chunk_map.at({ x, y, update_zmin })->UpdateChunk(m_chunk_map, *mp_world);`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
`195`		`- if (scene_x_need_update \|\| scene_z_need_update)`
`196`		`- p_scene->ToUpdate();`
`197`		`-`
`198`	`195`	`Watcher::WatchPosition("render position", m_render_position);`
`199`	`196`	`Watcher::WatchPosition("render max", m_render_max);`
`200`	`197`	`Watcher::WatchPosition("render min", m_render_min);`
	`198`	`+`
	`199`	`+ return scene_x_need_update \|\| scene_z_need_update;`
`201`	`200`	`}`
`202`	`201`
`203`	`202`	`void ChunkManager::CreateNewChunk(int32_t x, int32_t y, int32_t z)`