private bool SaveData()
{
// We need to wait until chunk is generated
if (!m_completedStates.Check(ChunkState.PrepareSaveData))
{
return(true);
}
m_pendingStates = m_pendingStates.Reset(CurrStateSaveData);
m_completedStates = m_completedStates.Reset(CurrStateSaveData);
m_completedStatesSafe = m_completedStates;
if (Features.UseSerialization)
{
var task = Globals.MemPools.SMTaskPI.Pop();
m_poolState = m_poolState.Set(ChunkPoolItemState.TaskPI);
m_threadPoolItem = task;
task.Set(actionOnSaveData, this);
m_taskRunning = true;
IOPoolManager.Add(task);
return(true);
}
OnSaveDataDone(this, false);
return(false);
}
private bool PrepareGenerate()
{
if (!m_completedStates.Check(ChunkState.LoadData))
{
return(true);
}
m_pendingStates = m_pendingStates.Reset(CurrStatePrepareGenerate);
m_completedStates = m_completedStates.Reset(CurrStatePrepareGenerate);
m_completedStatesSafe = m_completedStates;
if (Features.UseSerialization)
{
var task = Globals.MemPools.SMThreadPI.Pop();
m_poolState = m_poolState.Set(ChunkPoolItemState.ThreadPI);
m_threadPoolItem = task;
task.Set(chunk.ThreadID, actionOnPrepareGenerate, this);
m_taskRunning = true;
IOPoolManager.Add(m_threadPoolItem);
return(true);
}
OnPrepareGenerateDone(this, false);
return(false);
}
public override void Reset()
{
base.Reset();
SubscribeNeighbors(false);
m_stateExternal = ChunkStateExternal.None;
Visible = false;
PossiblyVisible = false;
m_syncEdgeBlocks = true;
m_poolState = m_poolState.Reset();
m_threadPoolItem = null;
}
private void ReturnPoolItems()
{
var pools = Globals.MemPools;
// Global.MemPools is not thread safe and were returning values to it from a different thread.
// Therefore, each client remembers which pool it used and once the task is finished it returns
// it back to the pool as soon as possible from the main thread
if (m_poolState.Check(ChunkPoolItemState.ThreadPI))
{
pools.SMThreadPI.Push(m_threadPoolItem as ThreadPoolItem <ChunkStateManagerClient>);
}
else if (m_poolState.Check(ChunkPoolItemState.TaskPI))
{
pools.SMTaskPI.Push(m_threadPoolItem as TaskPoolItem <ChunkStateManagerClient>);
}
m_poolState = m_poolState.Reset();
m_threadPoolItem = null;
}
/// <summary>
/// Build this chunk's geometry
/// </summary>
private bool BuildVertices()
{
if (!m_completedStates.Check(ChunkState.Generate))
{
return(true);
}
if (!SynchronizeChunk())
{
return(true);
}
bool priority = m_pendingStates.Check(ChunkState.BuildVerticesNow);
m_pendingStates = m_pendingStates.Reset(ChunkStates.CurrStateBuildVertices);
m_completedStates = m_completedStates.Reset(ChunkStates.CurrStateBuildVertices);
m_completedStatesSafe = m_completedStates;
if (chunk.blocks.NonEmptyBlocks > 0)
{
var task = Globals.MemPools.SMThreadPI.Pop();
m_poolState = m_poolState.Set(ChunkPoolItemState.ThreadPI);
m_threadPoolItem = task;
task.Set(
chunk.ThreadID,
actionOnBuildVertices,
this,
priority ? Globals.Watch.ElapsedTicks : long.MinValue
);
m_taskRunning = true;
WorkPoolManager.Add(task, priority);
return(true);
}
OnBuildVerticesDone(this);
return(false);
}
private bool LoadData()
{
m_pendingStates = m_pendingStates.Reset(CurrStateLoadData);
m_completedStates = m_completedStates.Reset(CurrStateLoadData);
m_completedStatesSafe = m_completedStates;
if (Features.UseSerialization)
{
var task = Globals.MemPools.SMTaskPI.Pop();
m_poolState = m_poolState.Set(ChunkPoolItemState.TaskPI);
m_threadPoolItem = task;
task.Set(actionOnLoadData, this);
m_taskRunning = true;
IOPoolManager.Add(m_threadPoolItem);
return(true);
}
OnLoadDataDone(this, false);
return(false);
}
private bool GenerateData()
{
if (!m_completedStates.Check(ChunkState.LoadData))
{
return(true);
}
m_pendingStates = m_pendingStates.Reset(CurrStateGenerateData);
m_completedStates = m_completedStates.Reset(CurrStateGenerateData);
m_completedStatesSafe = m_completedStates;
var task = Globals.MemPools.SMThreadPI.Pop();
m_poolState = m_poolState.Set(ChunkPoolItemState.ThreadPI);
m_threadPoolItem = task;
task.Set(chunk.ThreadID, actionOnGenerateData, this);
m_taskRunning = true;
WorkPoolManager.Add(task, false);
return(true);
}
public void AddItem(ITaskPoolItem item)
{
Assert.IsNotNull(item);
m_itemsTmp.Add(item);
}
public void AddPriorityItem(ITaskPoolItem item)
{
Assert.IsNotNull(item);
m_itemsTmpP.Add(item);
}
public static void Add(ITaskPoolItem action)
{
WorkItems.Add(action);
}