Exemplo n.º 1
0
        private bool SerializeChunk()
        {
            // This state should only be set it streaming is enabled
            Assert.IsTrue(EngineSettings.WorldConfig.Streaming);

            // If chunk was generated...
            if (m_completedTasks.Check(ChunkState.Generate))
            {
                // ...  we need to wait until blueprints are generated and chunk is finalized
                if (!m_completedTasks.Check(
#if ENABLE_BLUEPRINTS
                        ChunkState.GenerateBlueprints |
#endif
                        ChunkState.FinalizeData
                        ))
                {
                    return(true);
                }
            }

            m_pendingTasks = m_pendingTasks.Reset(CurrStateSerializeChunk);

            // Nothing here for us to do if the chunk was not changed since the last serialization
            if (m_completedTasks.Check(CurrStateSerializeChunk) && !m_refreshTasks.Check(CurrStateSerializeChunk))
            {
                OnSerialzeChunkDone(this);
                return(false);
            }

            m_refreshTasks   = m_refreshTasks.Reset(CurrStateSerializeChunk);
            m_completedTasks = m_completedTasks.Reset(CurrStateSerializeChunk);

            ChunkProvider      provider = (ChunkProvider)Map.ChunkProvider;
            SSerializeWorkItem workItem = new SSerializeWorkItem(
                this,
                provider.GetFilePathFromIndex(Pos.X, Pos.Y, Pos.Z)
                );

            m_taskRunning = true;
            IOPoolManager.Add(new ThreadItem(
                                  arg =>
            {
                SSerializeWorkItem item = (SSerializeWorkItem)arg;
                OnSerializeChunk(item.Chunk, item.FilePath);
            },
                                  workItem)
                              );

            return(true);
        }
Exemplo n.º 2
0
        private bool SaveData()
        {
            // This state should only be set it streaming is enabled
            Assert.IsTrue(EngineSettings.WorldConfig.Streaming);

            // If chunk was generated...
            if (m_completedStates.Check(ChunkState.Generate))
            {
                // ...  we need to wait until blueprints are generated and chunk is finalized
                if (!m_completedStates.Check(
                        ChunkState.FinalizeData
                        ))
                {
                    return(true);
                }
            }

            m_pendingStates       = m_pendingStates.Reset(CurrStateSaveData);
            m_completedStates     = m_completedStates.Reset(CurrStateSaveData);
            m_completedStatesSafe = m_completedStates;

            ChunkProvider      provider = (ChunkProvider)chunk.Map.ChunkProvider;
            SSerializeWorkItem workItem = new SSerializeWorkItem(
                this,
                provider.GetFilePathFromIndex(chunk.Pos.X, chunk.Pos.Y, chunk.Pos.Z)
                );

            m_taskRunning = true;
            IOPoolManager.Add(
                new TaskPoolItem(
                    arg =>
            {
                SSerializeWorkItem item = (SSerializeWorkItem)arg;
                OnSaveData(item.StateManager, item.FilePath);
            },
                    workItem)
                );

            return(true);
        }