private bool AbortRequest(int tx, int tz, string reason)
{
bool result = false;
// This is a thorough check, taking into account potential errors.
for (int i = mNMGenTasks.Count - 1; i >= 0; i--)
{
NMGenTask item = mNMGenTasks[i];
if (item.TileX == tx && item.TileZ == tz)
{
item.Abort(reason);
mNMGenTasks.RemoveAt(i);
mBuild.BuildData.ClearUnbaked(tx, tz);
result = true;
}
}
for (int i = mTileTasks.Count - 1; i >= 0; i--)
{
TileBuildTask item = mTileTasks[i];
if (item.TileX == tx && item.TileZ == tz)
{
item.Abort(reason);
mTileTasks.RemoveAt(i);
mBuild.BuildData.ClearUnbaked(tx, tz);
result = true;
}
}
return(result);
}
public bool QueueTask(BuildContext context
, int tx, int tz
, PolyMesh polyMesh, PolyMeshDetail detailMesh
, bool bvTreeEnabled
, int priority)
{
TileBuildTask task = TileBuildTask.Create(tx, tz
, polyMesh.GetData(false)
, (detailMesh == null ? null : detailMesh.GetData(true))
, Build.Connections
, bvTreeEnabled
, true
, priority);
if (!mTaskProcessor.QueueTask(task))
{
context.LogError("Task processor rejected task.", this);
return(false);
}
mTileTasks.Add(task);
return(true);
}
private bool BuildMultiTiled()
{
TileSetDefinition tdef = mBuild.TileSetDefinition;
TileBuildData tdata = mBuild.BuildData;
mContext.ResetLog();
int total = tdef.Width * tdef.Depth;
string msg = string.Format("Multi-tile build: {0} tiles ({1}x{2})"
, total, tdef.Width, tdef.Depth);
mContext.Log(msg, mBuild);
int count = 0; // For the progress bar.
for (int tx = 0; tx < tdef.Width; tx++)
{
for (int tz = 0; tz < tdef.Depth; tz++)
{
count++;
string tileText = string.Format("({0},{1})", tx, tz);
if (EditorUtility.DisplayCancelableProgressBar("Multi-tiled Build & Bake"
, string.Format("Tile: {0} ({1} of {2})", tileText, count, total)
, (float)count / total))
{
return(false);
}
// Create the NMGen builder.
IncrementalBuilder builder = IncrementalBuilder.Create(tx, tz
, mBuild.Config.ResultOptions
, mBuild.TileSetDefinition
, mBuild.NMGenProcessors);
if (builder == null)
{
mContext.PostError(
"Unexpected failure creating NMGen builder: Tile: " + tileText
, mBuild);
tdata.SetAsFailed(tx, tz);
return(false);
}
mBuild.BuildData.SetAsInProgress(tx, tz);
// Create and run the build task.
NMGenTask ntask = NMGenTask.Create(builder, 0);
ntask.Run();
if (ntask.TaskState == BuildTaskState.Aborted)
{
mContext.PostError("NMGen build task failed: Tile: " + tileText
, ntask.Messages, mBuild);
tdata.SetAsFailed(tx, tz);
return(false);
}
NMGenAssets nr = ntask.Result;
if (nr.NoResult)
{
mContext.PostTrace("NMGen complete. Empty tile: " + tileText
, builder.GetMessages()
, mBuild);
tdata.SetAsEmpty(tx, tz);
continue;
}
msg = string.Format("NMGen complete. Tile {0} has {1} polygons."
, tileText, nr.PolyMesh.PolyCount);
mContext.PostTrace(msg, builder.GetMessages(), mBuild);
TileBuildTask ttask = TileBuildTask.Create(tx, tz
, nr.PolyMesh.GetData(false), nr.DetailMesh.GetData(false)
, mBuild.Connections
, (mBuild.Config.BuildFlags & NMGenBuildFlag.BVTreeEnabled) != 0
, false, 0);
ttask.Run();
if (ttask.TaskState == BuildTaskState.Aborted)
{
mContext.PostError("Tile build task failed: Tile: " + tileText
, ttask.Messages
, mBuild);
tdata.SetAsFailed(tx, tz);
return(false);
}
TileBuildAssets tr = ttask.Result;
tdata.SetWorkingData(tx, tz, nr.PolyMesh, nr.DetailMesh);
tdata.SetWorkingData(tx, tz, tr.Tile, tr.PolyCount);
}
}
int bakeable = tdata.BakeableCount();
if (bakeable == 0)
{
mContext.PostError("Build did not produce any usuable tiles. (All tiles empty?)"
, mBuild);
return(false);
}
msg = string.Format("Tile build complete. {0} tiles produced. {1} empty tiles."
, bakeable, tdata.GetStateCount(TileBuildState.Empty));
mContext.PostTrace(msg, mBuild);
return(true);
}
private void ManageTileRequests()
{
TileBuildData tdata = mContext.Build.BuildData;
mLogger.ResetLog();
// Due to concurrency with the input build, this method
// does not log things via the context.
List <TileBuildTask> requests = mContext.TileTasks;
for (int i = requests.Count - 1; i >= 0; i--)
{
TileBuildTask item = requests[i];
if (item.IsFinished)
{
requests.RemoveAt(i);
NavmeshBuild build = mContext.Build;
if (!build)
{
// Asset was deleted.
continue;
}
string tileText = string.Format("({0},{1})", item.TileX, item.TileZ);
switch (item.TaskState)
{
case BuildTaskState.Aborted:
mLogger.Log(item.Messages);
mLogger.PostError("Tile build failed: " + tileText, build);
tdata.SetAsFailed(item.TileX, item.TileZ);
break;
case BuildTaskState.Complete:
TileBuildAssets r = item.Result;
string msg;
if (r.NoResult)
{
msg = "Tile build complete. Tile is empty: " + tileText;
tdata.SetAsEmpty(r.TileX, r.TileZ);
}
else
{
msg = "Tile build complete: " + tileText;
tdata.SetWorkingData(r.TileX, r.TileZ, r.Tile, r.PolyCount);
}
mLogger.PostTrace(msg, item.Messages, build);
break;
}
}
}
}
