Planet: Load chunks as necessary when visibility mask updates

Author: SirLynix

include/CommonLib/Planet.hpp

@@ -62,6 +62,8 @@ namespace tsom
 			Planet& operator=(const Planet&) = delete;
 			Planet& operator=(Planet&&) = delete;
 
+			NazaraSignal(OnChunkVisibilityMaskUpdated, Planet* /*planet*/, Chunk* /*chunk*/, DirectionMask /*oldVisibilityMask*/, DirectionMask /*newVisibilityMask*/);
+
 			static constexpr unsigned int ChunkSize = 32;
 
 		protected:

include/ServerLib/ServerPlanetEnvironment.hpp

@@ -11,7 +11,7 @@
 #include <CommonLib/Chunk.hpp>
 #include <ServerLib/ServerAtmosphere.hpp>
 #include <ServerLib/ServerEnvironment.hpp>
-#include <tsl/hopscotch_set.h>
+#include <tsl/hopscotch_map.h>
 #include <atomic>
 #include <filesystem>
 #include <mutex>
@@ -63,9 +63,9 @@ namespace tsom
 				std::mutex mutex;
 				std::shared_ptr<Planet> planet;
 				std::queue<ChunkIndices> remainingChunks;
-				tsl::hopscotch_set<ChunkIndices> visitedChunks;
+				tsl::hopscotch_map<ChunkIndices, bool> visitedChunks;
 
-				void HandleChunkLoaded(const ChunkIndices& chunkIndices);
+				void HandleChunkLoaded(const ChunkIndices& chunkIndices, DirectionMask visibilityMask);
 			};
 
 			ServerAtmosphere m_atmosphere;

scripts/planets/bob.lua

@@ -63,7 +63,7 @@ return function (chunk, seed)
                             table.insert(content, dirtBlock)
                         end
                     else
-                        table.insert(content, emptyBlock)
+                        table.insert(content, stoneBlock)
                     end
                 else
                     local baseMountainous = perlin:normalizedOctave3D_01((blockPosNorm.x * moutainScale)+10, blockPosNorm.y * moutainScale, blockPosNorm.z * moutainScale, 4, 0.1)

src/CommonLib/Planet.cpp

@@ -110,11 +110,17 @@ namespace tsom
 					}
 				}
 
+				DirectionMask oldVisibilityMask = chunkData.visibilityMask;
+				chunkData.visibilityMask.Clear();
+
 				for (auto&& [direction, holeCount] : chunkData.directionHoleCount.iter_kv())
 				{
 					if (holeCount > 0)
 						chunkData.visibilityMask |= direction;
 				}
+
+				if (oldVisibilityMask != chunkData.visibilityMask)
+					OnChunkVisibilityMaskUpdated(this, chunk, oldVisibilityMask, chunkData.visibilityMask);
 			}
 
 			// FIXME: Nz::Signal operator() is not thread-safe!
@@ -196,6 +202,8 @@ namespace tsom
 					NazaraAssert(chunkIt != m_chunks.end());
 					ChunkData& chunkData = chunkIt.value();
 
+					DirectionMask oldVisibilityMask = chunkData.visibilityMask;
+
 					if (previousBlockData.isTransparent)
 					{
 						// We're putting an opaque block on a transparent one
@@ -215,6 +223,9 @@ namespace tsom
 							chunkData.visibilityMask |= direction;
 						}
 					}
+
+					if (oldVisibilityMask != chunkData.visibilityMask)
+						OnChunkVisibilityMaskUpdated(this, chunk, oldVisibilityMask, chunkData.visibilityMask);
 				}
 			}
 

src/ServerLib/ServerPlanetEnvironment.cpp

@@ -54,10 +54,20 @@ namespace tsom
 
 		auto& planetComponent = m_planetEntity.get<PlanetComponent>();
 
+		ChunkIndices firstChunkIndices(-int(m_chunkCount.x / 2), -int(m_chunkCount.y / 2), -int(m_chunkCount.z / 2));
+
 		m_chunkLoadingData = std::make_shared<ChunkLoadingData>();
 		m_chunkLoadingData->chunkCount = m_chunkCount;
 		m_chunkLoadingData->planet = planetComponent.planet;
-		m_chunkLoadingData->remainingChunks.emplace(-int(m_chunkCount.x / 2), -int(m_chunkCount.y / 2), -int(m_chunkCount.z / 2));
+		m_chunkLoadingData->remainingChunks.emplace(firstChunkIndices);
+		m_chunkLoadingData->visitedChunks.emplace(firstChunkIndices, true);
+
+		GetPlanet().OnChunkVisibilityMaskUpdated.Connect([chunkLoadingData = m_chunkLoadingData](Planet* /*planet*/, Chunk* chunk, DirectionMask oldVisibilityMask, DirectionMask newVisibilityMask)
+		{
+			DirectionMask newDirectionMask = newVisibilityMask & ~oldVisibilityMask;
+			chunkLoadingData->visitedChunks[chunk->GetIndices()] = true;
+			chunkLoadingData->HandleChunkLoaded(chunk->GetIndices(), newDirectionMask);
+		});
 
 		//planetComponent.planet->GeneratePlatform(blockLibrary, Direction::Right, { 65, -18, -39 });
 		//planetComponent.planet->GeneratePlatform(blockLibrary, Direction::Back, { -34, 2, 53 });
@@ -264,7 +274,8 @@ namespace tsom
 			if (!chunkFound)
 				chunkLoadingData->planet->GenerateChunk(*chunk, seed, chunkCount, generatorName);
 
-			chunkLoadingData->HandleChunkLoaded(chunk->GetIndices());
+			DirectionMask visibilityMask = chunkLoadingData->planet->GetChunkVisibilityMask(chunk->GetIndices());
+			chunkLoadingData->HandleChunkLoaded(chunk->GetIndices(), visibilityMask);
 
 			if (--chunkLoadingData->chunkLoadingCount == 0 && chunkLoadingData->remainingChunks.empty())
 				spdlog::debug("planet chunk loading finished, total chunks: {} (out of {})", chunkLoadingData->visitedChunks.size(), chunkCount.x * chunkCount.y * chunkCount.z);
@@ -344,26 +355,36 @@ namespace tsom
 		});
 	}
 
-	void ServerPlanetEnvironment::ChunkLoadingData::HandleChunkLoaded(const ChunkIndices& chunkIndices)
+	void ServerPlanetEnvironment::ChunkLoadingData::HandleChunkLoaded(const ChunkIndices& chunkIndices, DirectionMask visibilityMask)
 	{
 		ChunkIndices minIndices(-int(chunkCount.x / 2), -int(chunkCount.y / 2), -int(chunkCount.z / 2));
 		ChunkIndices maxIndices = minIndices + ChunkIndices(chunkCount) - ChunkIndices(1);
 
 		std::unique_lock lock(mutex);
 
-		DirectionMask visibilityMask = planet->GetChunkVisibilityMask(chunkIndices);
-		for (Direction visibleNeighborDir : visibilityMask)
+		// Direct neighbor can trigger indirect neighbor
+		bool isPrimaryChunk = Nz::Retrieve(visitedChunks, chunkIndices);
+
+		for (Direction direction : DirectionMask_All)
 		{
-			ChunkIndices neighborIndices = chunkIndices + s_chunkDirOffset[visibleNeighborDir];
-			if (neighborIndices.x < minIndices.x || neighborIndices.x > maxIndices.x ||
-			    neighborIndices.y < minIndices.y || neighborIndices.y > maxIndices.y ||
-			    neighborIndices.z < minIndices.z || neighborIndices.z > maxIndices.z)
+			bool isNeighborPrimaryChunk = visibilityMask.Test(direction);
+			if (!isPrimaryChunk && !isNeighborPrimaryChunk)
 				continue;
 
-			if (visitedChunks.contains(neighborIndices))
+			ChunkIndices neighborIndices = chunkIndices + s_chunkDirOffset[direction];
+			if (neighborIndices.x < minIndices.x || neighborIndices.x > maxIndices.x
+			 || neighborIndices.y < minIndices.y || neighborIndices.y > maxIndices.y
+			 || neighborIndices.z < minIndices.z || neighborIndices.z > maxIndices.z)
 				continue;
 
-			visitedChunks.insert(neighborIndices);
+			auto it = visitedChunks.find(neighborIndices);
+			if (it != visitedChunks.end())
+			{
+				it.value() |= isNeighborPrimaryChunk;
+				continue;
+			}
+
+			visitedChunks.emplace(neighborIndices, isNeighborPrimaryChunk);
 			remainingChunks.push(neighborIndices);
 		}
 	}