private void SubscribeTwoNeighbors(Vector3Int neighborPos, bool subscribe) { World world = chunk.world; if (world == null) { return; } // No chunk lookup if the neighbor positions can't be contained in the world //if (!world.CheckInsideWorld(neighborPos)) //return; Chunk neighbor = world.chunks.Get(ref neighborPos); if (neighbor == null) { return; } ChunkStateManagerClient stateManager = neighbor.stateManager; // Subscribe with each other. Passing Idle as event - it is ignored in this case anyway stateManager.Subscribe(this, ChunkState.Idle, subscribe); Subscribe(stateManager, ChunkState.Idle, subscribe); // Update required listener count of the neighbor UpdateListenersCount(stateManager); }
private static void OnGenericWork(ref SGenericWorkItem item) { ChunkStateManagerClient chunk = item.Chunk; item.Action(); OnGenericWorkDone(chunk); }
private static void OnBuildCollider(ChunkStateManagerClient client) { Chunk chunk = client.chunk; chunk.ChunkColliderGeometryHandler.Build(); OnBuildColliderDone(client); }
private static void OnGenerateCollider(ref SGenerateColliderWorkItem item) { ChunkStateManagerClient stateManager = item.StateManager; stateManager.chunk.ChunkColliderGeometryHandler.Build(item.MinX, item.MaxX, item.MinY, item.MaxY, item.MinZ, item.MaxZ); OnGenerateColliderDone(stateManager); }
private bool SaveData() { // We need to wait until chunk is generated and data finalized if (!m_completedStates.Check(ChunkState.Generate) || !m_completedStates.Check(ChunkState.LoadData)) { return(true); } m_pendingStates = m_pendingStates.Reset(CurrStateSaveData); m_completedStates = m_completedStates.Reset(CurrStateSaveData); m_completedStatesSafe = m_completedStates; m_taskRunning = true; IOPoolManager.Add( new TaskPoolItem( arg => { ChunkStateManagerClient stateManager = (ChunkStateManagerClient)arg; OnSaveData(stateManager); }, this) ); return(true); }
private static void OnBuildVertices(ChunkStateManagerClient client) { Chunk chunk = client.chunk; chunk.GeometryHandler.Build(); OnBuildVerticesDone(client); }
private bool GenerateData() { m_pendingStates = m_pendingStates.Reset(CurrStateGenerateData); m_completedStates = m_completedStates.Reset(CurrStateGenerateData | CurrStateLoadData); m_completedStatesSafe = m_completedStates; m_taskRunning = true; if (chunk.world.networking.isServer) { // Let server generate chunk data WorkPoolManager.Add( new ThreadPoolItem( chunk.ThreadID, arg => { ChunkStateManagerClient stateManager = (ChunkStateManagerClient)arg; OnGenerateData(stateManager); }, this) ); } else { // Client only asks for data chunk.world.networking.client.RequestChunk(chunk.pos); } return(true); }
private static void OnGenerateVerices(ref SGenerateVerticesWorkItem item) { ChunkStateManagerClient stateManager = item.StateManager; stateManager.chunk.GeometryHandler.Build(0, Env.ChunkMask, 0, Env.ChunkMask, 0, Env.ChunkMask); OnGenerateVerticesDone(stateManager); }
private static void OnGenerateData(ChunkStateManagerClient stateManager) { Chunk chunk = stateManager.chunk; chunk.world.terrainGen.GenerateTerrain(chunk); OnGenerateDataDone(stateManager); }
private static void UpdateListenersCount(ChunkStateManagerClient stateManager) { Chunk chunk = stateManager.chunk; World world = chunk.world; if (world == null) { return; } // Calculate how many listeners a chunk can have int maxListeners = 0; if (world.CheckInsideWorld(chunk.pos.Add(Env.ChunkSize, 0, 0)) && (chunk.pos.x != world.Bounds.maxX)) { ++maxListeners; } if (world.CheckInsideWorld(chunk.pos.Add(-Env.ChunkSize, 0, 0)) && (chunk.pos.x != world.Bounds.minX)) { ++maxListeners; } if (world.CheckInsideWorld(chunk.pos.Add(0, Env.ChunkSize, 0)) && (chunk.pos.y != world.Bounds.maxY)) { ++maxListeners; } if (world.CheckInsideWorld(chunk.pos.Add(0, -Env.ChunkSize, 0)) && (chunk.pos.y != world.Bounds.minY)) { ++maxListeners; } if (world.CheckInsideWorld(chunk.pos.Add(0, 0, Env.ChunkSize)) && (chunk.pos.z != world.Bounds.maxZ)) { ++maxListeners; } if (world.CheckInsideWorld(chunk.pos.Add(0, 0, -Env.ChunkSize)) && (chunk.pos.z != world.Bounds.minZ)) { ++maxListeners; } //int prevListeners = stateManager.ListenerCountMax; // Update max listeners and request geometry update stateManager.ListenerCountMax = maxListeners; // Request synchronization of edges and build geometry //if(prevListeners<maxListeners) stateManager.m_syncEdgeBlocks = true; // Geometry needs to be rebuild stateManager.RequestState(ChunkState.BuildVertices); // Collider might beed to be rebuild if (chunk.NeedsCollider) { chunk.blocks.RequestCollider(); } }
public SGenerateColliderWorkItem(ChunkStateManagerClient stateManager, int minX, int maxX, int minY, int maxY, int minZ, int maxZ) { StateManager = stateManager; MinX = minX; MaxX = maxX; MinY = minY; MaxY = maxY; MinZ = minZ; MaxZ = maxZ; }
private void SubscribeTwoNeighbors(Vector3Int neighborPos, bool subscribe) { Chunk neighbor = chunk.world.chunks.Get(neighborPos); if (neighbor != null) { ChunkStateManagerClient stateManager = (ChunkStateManagerClient)neighbor.stateManager; // Subscribe with each other. Passing Idle as event - it is ignored in this case anyway stateManager.Subscribe(this, ChunkState.Idle, subscribe); Subscribe(stateManager, ChunkState.Idle, subscribe); } }
private static void OnLoadDataDone(ChunkStateManagerClient stateManager, bool success) { if (success) { stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStateLoadData); stateManager.m_nextState = NextStateLoadData; } else { stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStateLoadData | ChunkState.PrepareGenerate); stateManager.m_nextState = ChunkState.Generate; } stateManager.m_taskRunning = false; }
private static void OnGenerateData(ChunkStateManagerClient stateManager) { Chunk chunk = stateManager.chunk; chunk.world.terrainGen.GenerateTerrain(chunk); // Commit serialization changes if any if (Features.UseSerialization) { stateManager.m_save.CommitChanges(); } // Calculate the amount of non-empty blocks chunk.blocks.CalculateEmptyBlocks(); //chunk.blocks.Compress(); //chunk.blocks.Decompress(); OnGenerateDataDone(stateManager); }
private static void OnSaveDataDone(ChunkStateManagerClient stateManager, bool success) { if (Features.UseSerialization) { if (success) { // Notify listeners in case of success stateManager.m_stateExternal = ChunkStateExternal.Saved; } else { // Free temporary memory in case of failure stateManager.m_save.MarkAsProcessed(); stateManager.m_completedStates = stateManager.m_completedStates.Set(ChunkState.SaveData); } } stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStateSaveData); stateManager.m_isSaveNeeded = false; stateManager.m_taskRunning = false; }
private static void OnPrepareSaveDataDone(ChunkStateManagerClient stateManager, bool success) { if (Features.UseSerialization) { if (!success) { // Free temporary memory in case of failure stateManager.m_save.MarkAsProcessed(); // Consider SaveData completed as well stateManager.m_completedStates = stateManager.m_completedStates.Set(NextStatePrepareSaveData); stateManager.m_isSaveNeeded = false; } else { stateManager.m_nextState = NextStatePrepareSaveData; } } stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStatePrepareSaveData); stateManager.m_taskRunning = false; }
private static void OnPrepareGenerateDone(ChunkStateManagerClient stateManager, bool success) { // Consume info about invalidated chunk stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStatePrepareGenerate); if (success) { if (stateManager.m_save.IsDifferential) { stateManager.m_nextState = NextStatePrepareGenerate; } else { stateManager.m_completedStates = stateManager.m_completedStates.Set(ChunkState.Generate); stateManager.m_nextState = ChunkState.BuildVertices; } } else { stateManager.m_nextState = NextStatePrepareGenerate; } stateManager.m_taskRunning = false; }
private bool LoadData() { if (!m_completedStates.Check(ChunkState.Generate)) { return(true); } m_pendingStates = m_pendingStates.Reset(CurrStateLoadData); m_completedStates = m_completedStates.Reset(CurrStateLoadData); m_completedStatesSafe = m_completedStates; m_taskRunning = true; IOPoolManager.Add( new TaskPoolItem( arg => { ChunkStateManagerClient stateManager = (ChunkStateManagerClient)arg; OnLoadData(stateManager); }, this) ); return(true); }
private static void OnBuildVerticesDone(ChunkStateManagerClient stateManager) { stateManager.m_completedStates = stateManager.m_completedStates.Set(ChunkStates.CurrStateBuildVertices); stateManager.m_taskRunning = false; }
private static void OnSaveData(ChunkStateManagerClient stateManager) { Serialization.Serialization.SaveChunk(stateManager.chunk); OnSaveDataDone(stateManager); }
private static void OnSaveDataDone(ChunkStateManagerClient stateManager) { stateManager.m_stateExternal = ChunkStateExternal.Saved; stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStateSaveData); stateManager.m_taskRunning = false; }
private static void OnSaveData(ChunkStateManagerClient stateManager) { bool success = Serialization.Serialization.Write(stateManager.m_save); OnSaveDataDone(stateManager, success); }
private static void OnGenerateColliderDone(ChunkStateManagerClient stateManager) { stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStateGenerateCollider); stateManager.m_taskRunning = false; }
public static void OnGenerateDataOverNetworkDone(ChunkStateManagerClient stateManager) { OnGenerateDataDone(stateManager); OnLoadDataDone(stateManager, false); //TODO: change to true once the network layers is implemented properly }
private static void OnGenerateDataDone(ChunkStateManagerClient stateManager) { stateManager.m_completedStates = stateManager.m_completedStates.Set(CurrStateGenerateData); stateManager.m_nextState = NextStateGenerateData; stateManager.m_taskRunning = false; }
public static void OnGenerateDataOverNetworkDone(ChunkStateManagerClient stateManager) { OnGenerateDataDone(stateManager); OnLoadDataDone(stateManager); }
private static void OnGenericWorkDone(ChunkStateManagerClient chunk) { chunk.m_completedStates = chunk.m_completedStates.Set(CurrStateGenericWork); chunk.m_nextState = NextStateGenericWork; chunk.m_taskRunning = false; }
private static void OnPrepareSaveData(ChunkStateManagerClient stateManager) { bool success = stateManager.m_save.DoCompression(); OnPrepareSaveDataDone(stateManager, success); }
private static void OnPrepareGenerate(ChunkStateManagerClient stateManager) { bool success = stateManager.m_save.DoDecompression(); OnPrepareGenerateDone(stateManager, success); }
public SGenerateVerticesWorkItem(ChunkStateManagerClient stateManager) { StateManager = stateManager; }