/// <summary>
/// Gets the result of the completed task.
/// </summary>
/// <param name="result">The result of the completed task.</param>
/// <returns>True if the result is available, false if the task should abort with no
/// result. (I.e. An internal abort.)</returns>
protected override bool GetResult(out TileBuildAssets result)
{
BuildContext logger = new BuildContext();
result = new TileBuildAssets();
NavmeshTileBuildData tbd =
NMBuild.GetBuildData(logger, mTileX, mTileZ
, mPolyData, (mDetailData == null ? null : mDetailData), mConnections
, mBVTreeEnabled);
AddMessages(logger.GetMessages());
if (tbd == null)
{
return(false);
}
NavmeshTileData td = NavmeshTileData.Create(tbd);
if (td.Size == 0)
{
AddMessage(string.Format(
"Could not create {2} object. Cause unknown."
+ " Tile: ({0},{1})"
, mTileX, mTileZ, td.GetType().Name));
return(false);
}
result = new TileBuildAssets(mTileX, mTileZ, td, tbd.PolyCount);
return(true);
}
internal NavmeshTileData GetTileData(int x, int z, out int polyCount)
{
polyCount = 0;
int i = GetIndex(x, z);
if (i == IndexError)
{
return(null);
}
BuildDataItem item = unsafeItems[i];
/*
* Important: Must use the state. This method must return
* the same number of tiles as the BakeableCount method indicates.
*/
switch (item.TileState)
{
case TileBuildState.Built:
polyCount = item.workingPolyCount;
return(NavmeshTileData.Create(item.workingTile));
case TileBuildState.Baked:
polyCount = item.bakedPolyCount;
return(NavmeshTileData.Create(item.bakedTile));
}
polyCount = 0;
return(null);
}
internal void SetWorkingData(NavmeshTileData tile, int polyCount)
{
if (tile == null || polyCount <= 0)
{
SetAsEmpty();
return;
}
workingTile = tile.GetData();
workingPolyCount = polyCount;
}
internal void SetWorkingData(int x, int z, NavmeshTileData tile, int polyCount)
{
int i = GetIndex(x, z);
if (i == IndexError)
{
return;
}
unsafeItems[i].SetWorkingData(tile, polyCount);
mIsDirty = true;
unsafeVersion++;
}
internal bool GetMeshBuildData(UnityEngine.Vector3 origin, float tileWorldSize, TileZone zone
, out NavmeshParams config
, out NavmeshTileData[] tiles)
{
// Is there anything to bake?
config = null;
tiles = null;
int maxPolyCount;
int tileCount;
BakeableCount(out tileCount, out maxPolyCount);
if (tileCount == 0)
{
return(false);
}
config = new NavmeshParams(origin.ToVector3()
, tileWorldSize, tileWorldSize
, Mathf.Max(1, tileCount)
, Mathf.Max(1, maxPolyCount));
// Add the tiles.
List <NavmeshTileData> ltiles = new List <NavmeshTileData>();
for (int tx = zone.xmin; tx <= zone.xmax; tx++)
{
for (int tz = zone.zmin; tz <= zone.zmax; tz++)
{
int trash;
NavmeshTileData td = GetTileData(tx, tz, out trash);
if (td == null)
{
// Tile is not available.
continue;
}
ltiles.Add(td);
}
}
tiles = ltiles.ToArray();
return(true);
}
/// <summary>
/// Constructor
/// </summary>
/// <remarks>
/// <para>
/// A 'no result' object will be created if the <paramref name="tile"/> parameter
/// is null or polygon count is less than one.
/// </para>
/// </remarks>
/// <param name="tx">The x-index of the tile within the tile grid. (tx, tz)</param>
/// <param name="tz">The z-index of the tile within the tile grid. (tx, tz)</param>
/// <param name="tile">The tile data.</param>
/// <param name="polyCount">The polygons in the tile.</param>
public TileBuildAssets(int tx, int tz, NavmeshTileData tile, int polyCount)
{
mTileX = tx;
mTileZ = tz;
if (tile == null || polyCount < 1)
{
mTile = null;
mPolyCount = 0;
}
else
{
mTile = tile;
mPolyCount = polyCount;
}
}
private void HandleBake()
{
NavmeshBuild build = Context.Build;
NavmeshTileData[] tiles = new NavmeshTileData[1]
{
build.BuildData.GetTileData(0, 0)
};
NavmeshParams nconfig = NavUtil.DeriveConfig(tiles[0]);
NavStatus status = build.BuildTarget.Load(nconfig, tiles, NMBEditorUtil.GetConfig(build));
if ((status & NavStatus.Failure) == 0)
{
EditorUtility.SetDirty((Object)build.BuildTarget);
// build.BuildData.SetAsBaked();
build.BuildData.Reset(0, 0); // Don't need to keep the data.
}
else
{
Logger.PostError("Bake to target: Target reported failure.", (Object)build.BuildTarget);
}
}
public void Build()
{
if (!mBuild)
{
return;
}
mBuild.ResetBuild();
// Note: The 'finally' takes care of all cleanup.
try
{
EditorUtility.DisplayCancelableProgressBar("Build & Bake"
, "Preparing..."
, 0);
// Prepare the build.
if (!CompileInput())
{
return;
}
if (!InitializeBuild())
{
return;
}
// Build the tiles.
NavmeshParams nconfig = null;
NavmeshTileData[] tiles = null;
bool success = true;
if (mBuild.TileSetDefinition == null)
{
if (!BuildSingleTile())
{
return;
}
tiles = new NavmeshTileData[1] {
mBuild.BuildData.GetTileData(0, 0)
};
nconfig = NavUtil.DeriveConfig(tiles[0]);
}
else if (BuildMultiTiled())
{
success = mBuild.BuildData.GetMeshBuildData(mBuild.TileSetDefinition.BoundsMin
, mBuild.TileSetDefinition.TileWorldSize
, out nconfig, out tiles);
}
else
{
return;
}
if (!success)
{
mContext.PostError("Navigation mesh creation failed.", mBuild);
return;
}
// Bake the mesh.
NavStatus nstatus =
mBuild.BuildTarget.Load(nconfig, tiles, NMBEditorUtil.GetConfig(mBuild));
if ((nstatus & NavStatus.Sucess) == 0)
{
mContext.PostError("Bake to target: Target reported failure.", mBuild);
}
else
{
EditorUtility.SetDirty((Object)mBuild.BuildTarget);
}
}
finally
{
mBuild.ResetBuild();
EditorUtility.ClearProgressBar();
}
}
private bool BuildSingleTile()
{
TileBuildData tdata = mBuild.BuildData;
NMGenConfig config = mBuild.Config;
InputGeometry geom = mBuild.InputGeom;
mContext.ResetLog();
/*
* Design note:
*
* Not using the build task since it doesn't provide enough progress
* feedback for a single tile.
*
*/
// Create the NMGen builder.
IncrementalBuilder builder = IncrementalBuilder.Create(config.GetConfig()
, config.ResultOptions
, geom
, mBuild.NMGenProcessors);
if (builder == null)
{
mContext.PostError("Unexpected failure creating NMGen builder.", mBuild);
tdata.SetAsFailed(0, 0);
return(false);
}
else if (builder.IsFinished)
{
if (builder.State == NMGenState.NoResult)
{
mContext.PostError("NMGen build did not produce a result. (Early exit.)"
, builder.GetMessages(), mBuild);
tdata.SetAsFailed(0, 0);
return(false);
}
else
{
mContext.PostError("Unexpected NMGen builder completion."
, builder.GetMessages(), mBuild);
tdata.SetAsFailed(0, 0);
return(false);
}
}
mBuild.BuildData.SetAsInProgress(0, 0);
// Run the NMGen builder.
while (!builder.IsFinished)
{
if (EditorUtility.DisplayCancelableProgressBar("Build Single Tile Mesh"
, IncrementalBuilder.ToLabel(builder.State)
, IncrementalBuilder.ToProgress(builder.State)))
{
return(false);
}
builder.Build();
}
// Handle NMGen failures.
mContext.Log(builder.GetMessages()); // Single tile build. So go ahead an record.
switch (builder.State)
{
case NMGenState.Aborted:
mContext.PostError("NMGen build failed.", mBuild);
tdata.SetAsFailed(0, 0);
return(false);
case NMGenState.NoResult:
mContext.PostError("NMGen build did not produce a result.", mBuild);
tdata.SetAsFailed(0, 0);
return(false);
}
mContext.Log(string.Format("Completed NMGen build: {0} polygons."
, builder.Result.PolyMesh.PolyCount)
, mBuild);
// Build the tile.
NMGenAssets result = builder.Result;
if (result.DetailMesh == null)
{
Debug.LogError("result.DetailMesh ==null!");
}
NavmeshTileBuildData tbd = org.critterai.nmbuild.NMBuild.GetBuildData(
mContext, 0, 0
, result.PolyMesh.GetData(false), result.DetailMesh.GetData(false)
, mBuild.Connections
, (config.BuildFlags & NMGenBuildFlag.BVTreeEnabled) != 0);
if (tbd == null)
{
// No need to log the error. The above method takes care of that.
tdata.SetAsFailed(0, 0);
return(false);
}
NavmeshTileData td = NavmeshTileData.Create(tbd);
if (td.Size == 0)
{
mContext.PostError(
"Could not create {0} object. Cause unknown." + typeof(NavmeshTileData)
, mBuild);
tdata.SetAsFailed(0, 0);
return(false);
}
// Finalize the tile.
tdata.SetWorkingData(0, 0, result.PolyMesh, result.DetailMesh);
tdata.SetWorkingData(0, 0, td, tbd.PolyCount);
mContext.PostTrace("Completed single tile build.", mBuild);
return(true);
}
private void HandleWorkingNavmesh(TileSelection selection)
{
NavmeshBuild build = selection.Build;
TileBuildData tdata = build.BuildData;
if (mDebugObject == null)
{
Navmesh navmesh = null;
if (tdata.BakeableCount() == 0)
{
// Nothing to display.
return;
}
bool success = true;
TileSetDefinition tdef = build.TileSetDefinition;
NavmeshParams nconfig;
NavmeshTileData[] tiles;
if (tdef == null)
{
tiles = new NavmeshTileData[1] {
tdata.GetTileData(0, 0)
};
nconfig = NavUtil.DeriveConfig(tiles[0]);
}
else
{
TileZone zone;
if (selection.HasSelection)
{
zone = selection.Zone;
}
else
{
zone = new TileZone(0, 0, tdef.Width - 1, tdef.Depth - 1);
}
success = tdata.GetMeshBuildData(tdef.BoundsMin.ToUnityVector3(), tdef.TileWorldSize, zone
, out nconfig, out tiles);
}
NavStatus status = NavStatus.Sucess;
if (success)
{
status = Navmesh.Create(nconfig, out navmesh);
if ((status & NavStatus.Failure) == 0)
{
foreach (NavmeshTileData tile in tiles)
{
uint trash;
status = navmesh.AddTile(tile, Navmesh.NullTile, out trash);
if ((status & NavStatus.Sucess) == 0)
{
navmesh = null;
break;
}
}
}
}
if ((status & NavStatus.Sucess) == 0)
{
Show = MeshDebugOption.None; // Use property.
Debug.LogError("Mesh Debug View: Error creating working navigation mesh: "
+ status + ". Disabled display.", build);
}
else
{
mDebugObject = navmesh;
}
}
if (mDebugObject != null)
{
Navmesh nm = ( Navmesh )mDebugObject;
NavDebug.Draw(nm, NavmeshSceneDraw.Instance.ColorByArea);
}
}
public static extern void dtnmFreeTileData(NavmeshTileData tileData);
public static extern void dtnmFreeTileData(NavmeshTileData tileData);
public static extern bool dtnmBuildTileDataRaw([In] byte[] rawData
, int dataSize
, [In, Out] NavmeshTileData resultTile);
public static extern bool dtnmBuildTileData(NavmeshTileBuildData sourceData
, [In, Out] NavmeshTileData resultTile);
public static extern NavStatus dtnmAddTile(IntPtr navmesh
, [In, Out] NavmeshTileData tileData
, uint lastRef
, ref uint resultRef);
