public override TiledNavMesh Deserialize(string path)
{
JObject root = JObject.Parse(File.ReadAllText(path));
if (root["meta"]["version"]["snj"].ToObject <int>() != FormatVersion)
{
throw new ArgumentException("The version of the file does not match the version of the parser. Consider using an older version of SharpNav or re-generating your .snj meshes.");
}
Vector3 origin = root["origin"].ToObject <Vector3>(serializer);
float tileWidth = root["tileWidth"].ToObject <float>(serializer);
float tileHeight = root["tileHeight"].ToObject <float>(serializer);
int maxTiles = root["maxTiles"].ToObject <int>(serializer);
int maxPolys = root["maxPolys"].ToObject <int>(serializer);
var mesh = new TiledNavMesh(origin, tileWidth, tileHeight, maxTiles, maxPolys);
JArray tilesToken = (JArray)root["tiles"];
List <MeshTile> tiles = new List <MeshTile>();
foreach (JToken tileToken in tilesToken)
{
PolyId tileRef;
MeshTile tile = DeserializeMeshTile(tileToken, mesh.IdManager, out tileRef);
mesh.AddTileAt(tile, tileRef);
}
return(mesh);
}
public override void Serialize(string path, TiledNavMesh mesh)
{
JObject root = new JObject();
root.Add("meta", JToken.FromObject(new
{
version = new
{
snj = FormatVersion,
sharpnav = Assembly.GetExecutingAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion
}
}));
root.Add("origin", JToken.FromObject(mesh.Origin, serializer));
root.Add("tileWidth", JToken.FromObject(mesh.TileWidth, serializer));
root.Add("tileHeight", JToken.FromObject(mesh.TileHeight, serializer));
root.Add("maxTiles", JToken.FromObject(mesh.MaxTiles, serializer));
root.Add("maxPolys", JToken.FromObject(mesh.MaxPolys, serializer));
var tilesArray = new JArray();
var tiles = (List <MeshTile>)GetPrivateField(mesh, typeof(TiledNavMesh), "tileList");
var tileRefs = (Dictionary <MeshTile, int>)GetPrivateField(mesh, typeof(TiledNavMesh), "tileRefs");
foreach (MeshTile tile in tiles)
{
tilesArray.Add(SerializeMeshTile(tile));
}
root.Add("tiles", tilesArray);
File.WriteAllText(path, root.ToString());
}
public override TiledNavMesh Deserialize(string path)
{
JObject root = JObject.Parse(File.ReadAllText(path));
//TODO error message?
if (root["meta"]["version"]["snj"].ToObject <int>() != FormatVersion)
{
return(null);
}
Vector3 origin = root["origin"].ToObject <Vector3>(serializer);
float tileWidth = root["tileWidth"].ToObject <float>(serializer);
float tileHeight = root["tileHeight"].ToObject <float>(serializer);
int maxTiles = root["maxTiles"].ToObject <int>(serializer);
int maxPolys = root["maxPolys"].ToObject <int>(serializer);
var mesh = new TiledNavMesh(origin, tileWidth, tileHeight, maxTiles, maxPolys);
JArray tilesToken = (JArray)root["tiles"];
List <MeshTile> tiles = new List <MeshTile>();
foreach (JToken tileToken in tilesToken)
{
mesh.AddTile(DeserializeMeshTile(tileToken, mesh.IdManager, mesh.GetNextTileRef()));
}
return(mesh);
}
//!!!!betauser
public TiledNavMesh Deserialize(MemoryStream memoryStream)
{
using (var binaryReader = new BinaryReader(memoryStream, System.Text.Encoding.Default, true))
{
var x = binaryReader.ReadSingle();
var y = binaryReader.ReadSingle();
var z = binaryReader.ReadSingle();
var origin = new Vector3(x, y, z);
var tileWidth = binaryReader.ReadSingle();
var tileHeight = binaryReader.ReadSingle();
var maxTiles = (int)binaryReader.ReadSingle();
var maxPolys = (int)binaryReader.ReadSingle();
var tiledNavMesh = new TiledNavMesh(origin, tileWidth, tileHeight, maxTiles, maxPolys);
var navTileCount = binaryReader.ReadInt32();
for (var i = 0; i < navTileCount; i++)
{
NavPolyId baseRef;
var stream = binaryReader.BaseStream;
var tile = DeserializeMeshTile(ref stream, tiledNavMesh.IdManager, out baseRef);
tiledNavMesh.AddTileAt(tile, baseRef);
}
return(tiledNavMesh);
}
}
public override void Serialize(string path, TiledNavMesh mesh)
{
JObject root = new JObject();
root.Add("meta", JToken.FromObject(new
{
version = new
{
snj = FormatVersion,
sharpnav = Assembly.GetExecutingAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion
}
}));
root.Add("origin", JToken.FromObject(mesh.Origin, serializer));
root.Add("tileWidth", JToken.FromObject(mesh.TileWidth, serializer));
root.Add("tileHeight", JToken.FromObject(mesh.TileHeight, serializer));
root.Add("maxTiles", JToken.FromObject(mesh.MaxTiles, serializer));
root.Add("maxPolys", JToken.FromObject(mesh.MaxPolys, serializer));
var tilesArray = new JArray();
foreach (NavTile tile in mesh.Tiles)
{
NavPolyId id = mesh.GetTileRef(tile);
tilesArray.Add(SerializeMeshTile(tile, id));
}
root.Add("tiles", tilesArray);
File.WriteAllText(path, root.ToString());
}
public bool MoveOverOffmeshConnection(NavPolyId offMeshConRef, NavPolyId[] refs, ref Vector3 startPos, ref Vector3 endPos, NavMeshQuery navquery)
{
//advance the path up to and over the off-mesh connection
NavPolyId prevRef = NavPolyId.Null, polyRef = path[0];
int npos = 0;
while (npos < path.Count && polyRef != offMeshConRef)
{
prevRef = polyRef;
polyRef = path[npos];
npos++;
}
if (npos == path.Count)
{
//could not find offMeshConRef
return(false);
}
//prune path
path.RemoveRange(0, npos);
refs[0] = prevRef;
refs[1] = polyRef;
TiledNavMesh nav = navquery.NavMesh;
if (nav.GetOffMeshConnectionPolyEndPoints(refs[0], refs[1], ref startPos, ref endPos) == true)
{
pos = endPos;
return(true);
}
return(false);
}
//!!!!betauser
public void Serialize(MemoryStream memoryStream, TiledNavMesh mesh)
{
using (var binaryWriter = new BinaryWriter(memoryStream, System.Text.Encoding.Default, true))
{
binaryWriter.Write(mesh.Origin.X);
binaryWriter.Write(mesh.Origin.Y);
binaryWriter.Write(mesh.Origin.Z);
binaryWriter.Write(mesh.TileWidth);
binaryWriter.Write(mesh.TileHeight);
binaryWriter.Write(mesh.MaxTiles);
binaryWriter.Write(mesh.MaxPolys);
var tiles = new List <byte[]>();
var navTiles = new List <NavTile>(mesh.Tiles);
binaryWriter.Write(navTiles.Count);
foreach (var tile in navTiles)
{
var baseRef = mesh.GetTileRef(tile);
tiles.Add(SerializeMeshTile(tile, baseRef));
}
foreach (var tile in tiles)
{
binaryWriter.Write(tile);
}
}
}
public override void Serialize(string path, TiledNavMesh mesh)
{
JObject root = new JObject();
root.Add("meta", JToken.FromObject(new
{
version = new
{
snj = FormatVersion,
sharpnav = Assembly.GetExecutingAssembly().GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion
}
}));
root.Add("origin", JToken.FromObject(mesh.Origin, serializer));
root.Add("tileWidth", JToken.FromObject(mesh.TileWidth, serializer));
root.Add("tileHeight", JToken.FromObject(mesh.TileHeight, serializer));
root.Add("maxTiles", JToken.FromObject(mesh.MaxTiles, serializer));
root.Add("maxPolys", JToken.FromObject(mesh.MaxPolys, serializer));
var tilesArray = new JArray();
var tiles = (List<MeshTile>) GetPrivateField(mesh, typeof(TiledNavMesh), "tileList");
var tileRefs = (Dictionary<MeshTile, int>)GetPrivateField(mesh, typeof(TiledNavMesh), "tileRefs");
foreach (MeshTile tile in tiles)
{
tilesArray.Add(SerializeMeshTile(tile));
}
root.Add("tiles", tilesArray);
File.WriteAllText(path, root.ToString());
}
public override TiledNavMesh Deserialize(string path)
{
JObject root = JObject.Parse(File.ReadAllText(path));
if (root["meta"]["version"]["snj"].ToObject<int>() != FormatVersion)
throw new ArgumentException("The version of the file does not match the version of the parser. Consider using an older version of SharpNav or re-generating your .snj meshes.");
Vector3 origin = root["origin"].ToObject<Vector3>(serializer);
float tileWidth = root["tileWidth"].ToObject<float>(serializer);
float tileHeight = root["tileHeight"].ToObject<float>(serializer);
int maxTiles = root["maxTiles"].ToObject<int>(serializer);
int maxPolys = root["maxPolys"].ToObject<int>(serializer);
var mesh = new TiledNavMesh(origin, tileWidth, tileHeight, maxTiles, maxPolys);
JArray tilesToken = (JArray) root["tiles"];
List<NavTile> tiles = new List<NavTile>();
foreach (JToken tileToken in tilesToken)
{
NavPolyId tileRef;
NavTile tile = DeserializeMeshTile(tileToken, mesh.IdManager, out tileRef);
mesh.AddTileAt(tile, tileRef);
}
return mesh;
}
private void LoadNavMeshFromFile(string path)
{
tiledNavMesh = new NavMeshJsonSerializer().Deserialize(path);
navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
hasGenerated = true;
displayMode = DisplayMode.NavMesh;
}
public override void Serialize(string path, TiledNavMesh mesh)
{
JObject root = new JObject();
SerializeNavMeshField(root, mesh, "origin");
SerializeNavMeshField(root, mesh, "tileWidth");
SerializeNavMeshField(root, mesh, "tileHeight");
SerializeNavMeshField(root, mesh, "maxTiles");
SerializeNavMeshField(root, mesh, "maxPolys");
SerializeNavMeshField(root, mesh, "tileLookupTableSize");
SerializeNavMeshField(root, mesh, "tileLookupTableMask");
SerializeNavMeshField(root, mesh, "saltBits");
SerializeNavMeshField(root, mesh, "tileBits");
SerializeNavMeshField(root, mesh, "polyBits");
SerializeNavMeshField(root, mesh, "nextFree");
var posLookup = (MeshTile[])GetPrivateField(mesh, typeof(TiledNavMesh), "posLookup");
root.Add("posLookup", SerializeMeshTilesArray(posLookup));
var tiles = (MeshTile[])GetPrivateField(mesh, typeof(TiledNavMesh), "tiles");
root.Add("tiles", SerializeMeshTilesArray(tiles));
File.WriteAllText(path, root.ToString());
}
public void JsonSerializationTest()
{
var objModel = new ObjModel("nav_test.obj");
TiledNavMesh mesh = NavMesh.Generate(objModel.GetTriangles(), NavMeshGenerationSettings.Default);
new NavMeshJsonSerializer().Serialize("mesh.snj", mesh);
TiledNavMesh deserializedMesh = new NavMeshJsonSerializer().Deserialize("mesh.snj");
}
private void SerializeNavMeshField(JObject root, TiledNavMesh mesh, string fieldName)
{
var field = GetPrivateField(mesh, typeof(TiledNavMesh), fieldName);
if (field != null)
{
root.Add(fieldName, JToken.FromObject(field, serializer));
}
}
static void TestNavmesh(NavMeshBuilder build)
{
// Azeroth 28 28 / Deathknell (wow-style coordinates)
// Outside church: 1843.734 1604.214 94.55994
// Inside church: 1844.074 1642.581 97.62832
// Outside spawn: 1672.226 1662.989 139.2343
// Inside spawn: 1665.264 1678.277 120.5302
// Outside cave: 2051.3 1807.121 102.5225
// Inside cave: 2082.813 1950.718 98.04765
// Outside house: 1861.465 1582.03 92.79533
// Upstairs house: 1859.929 1560.804 99.07755
var tmesh = new TiledNavMesh(build);
var query = new NavMeshQuery(tmesh, 65536);
var extents = new Vector3(5f, 5f, 5f);
var posStart = WoWToSharpNav(new Vector3(1665.2f, 1678.2f, 120.5f)); // Inside spawn
var posEnd = WoWToSharpNav(new Vector3(1672.2f, 1662.9f, 139.2f)); // Outside spawn
NavPoint endPt;
query.FindNearestPoly(ref posEnd, ref extents, out endPt);
NavPoint startPt;
query.FindNearestPoly(ref posStart, ref extents, out startPt);
var path = new List <int>();
if (!query.FindPath(ref startPt, ref endPt, path))
{
Console.WriteLine("No path!");
}
Vector3 actualStart = new Vector3();
query.ClosestPointOnPoly(startPt.Polygon, startPt.Position, ref actualStart);
Vector3 actualEnd = new Vector3();
query.ClosestPointOnPoly(endPt.Polygon, endPt.Position, ref actualEnd);
var smoothPath = new List <Vector3>();
Vector3[] straightPath = new Vector3[2048];
int[] pathFlags = new int[2048];
int[] pathRefs = new int[2048];
int pathCount = -1;
query.FindStraightPath(actualStart, actualEnd, path.ToArray(), path.Count, straightPath, pathFlags, pathRefs, ref pathCount, 2048, PathBuildFlags.AllCrossingVertices);
foreach (var v in straightPath)
{
Console.WriteLine(v);
}
}
public bool InitNavMesh( out string error )
{
DestroyNavMesh();
if( !EnabledInHierarchy )
{
error = "Is not enabled.";
return false;
}
if( NavMeshData == null )
{
error = "No data.";
return false;
}
//check version
var reader = new ArrayDataReader( NavMeshData );
if( reader.ReadInt32() != navMeshDataVersion )
{
error = "Invalid version.";
return false;
}
//read data
var dataLength = reader.ReadInt32();
var data = new byte[ dataLength ];
reader.ReadBuffer( data );
if( reader.BitPosition != reader.EndBitPosition || reader.Overflow )
{
error = "Invalid data.";
return false;
}
//init
try
{
using( var memoryStream = new MemoryStream( data ) )
{
var serializer = new NavMeshBinarySerializer();
tiledNavMesh = serializer.Deserialize( memoryStream );
}
}
catch( Exception e )
{
error = e.Message;
return false;
}
//!!!!
//TempObstaclesUpdate( true );
error = "";
return true;
}
private void DeserializeNavMeshField(JObject root, TiledNavMesh mesh, string fieldName, Type fieldType)
{
JToken token = root.GetValue(fieldName);
if (token != null)
{
var value = token.ToObject(fieldType);
SetPrivateField(mesh, typeof(TiledNavMesh), fieldName, value);
}
}
private World()
{
players = new Dictionary <int, Player>();
usedIds = new HashSet <int>();
entityIds = new HashSet <int>();
cts = new CancellationTokenSource();
stopwatch = new Stopwatch();
entities = new Dictionary <int, Entity>();
navMesh = NavMeshHelper.GetNavMesh() as TiledNavMesh;
crowd = new Crowd(256, 1f, ref navMesh);
}
public void JsonSerializationTest()
{
string objPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "nav_test.obj");
string snjPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "mesh.snj");
var objModel = new ObjModel(objPath);
TiledNavMesh mesh = NavMesh.Generate(objModel.GetTriangles(), NavMeshGenerationSettings.Default);
new NavMeshJsonSerializer().Serialize(snjPath, mesh);
TiledNavMesh deserializedMesh = new NavMeshJsonSerializer().Deserialize(snjPath);
}
/// <summary>
/// Initializes a new instance of the <see cref="Crowd" /> class.
/// </summary>
/// <param name="maxAgents">The maximum agents allowed</param>
/// <param name="maxAgentRadius">The maximum radius for an agent</param>
/// <param name="navMesh">The navigation mesh</param>
public Crowd(int maxAgents, float maxAgentRadius, ref TiledNavMesh navMesh)
{
this.maxAgents = maxAgents;
this.maxAgentRadius = maxAgentRadius;
this.ext = new Vector3(maxAgentRadius * 2.0f, maxAgentRadius * 1.5f, maxAgentRadius * 2.0f);
//initialize proximity grid
this.grid = new ProximityGrid<Agent>(maxAgents * 4, maxAgentRadius * 3);
//allocate obstacle avoidance query
this.obstacleQuery = new ObstacleAvoidanceQuery(6, 8);
//initialize obstancle query params
this.obstacleQueryParams = new ObstacleAvoidanceQuery.ObstacleAvoidanceParams[AgentMaxObstacleAvoidanceParams];
for (int i = 0; i < this.obstacleQueryParams.Length; i++)
{
this.obstacleQueryParams[i].VelBias = 0.4f;
this.obstacleQueryParams[i].WeightDesVel = 2.0f;
this.obstacleQueryParams[i].WeightCurVel = 0.75f;
this.obstacleQueryParams[i].WeightSide = 0.75f;
this.obstacleQueryParams[i].WeightToi = 2.5f;
this.obstacleQueryParams[i].HorizTime = 2.5f;
this.obstacleQueryParams[i].GridSize = 33;
this.obstacleQueryParams[i].AdaptiveDivs = 7;
this.obstacleQueryParams[i].AdaptiveRings = 2;
this.obstacleQueryParams[i].AdaptiveDepth = 5;
}
//allocate temp buffer for merging paths
this.maxPathResult = 256;
this.pathResult = new PolyId[this.maxPathResult];
this.pathq = new PathQueue(maxPathResult, 4096, ref navMesh);
this.agents = new Agent[maxAgents];
this.activeAgents = new Agent[maxAgents];
this.agentAnims = new AgentAnimation[maxAgents];
for (int i = 0; i < maxAgents; i++)
{
this.agents[i] = new Agent(maxPathResult);
}
for (int i = 0; i < maxAgents; i++)
{
this.agentAnims[i].Active = false;
}
//allocate nav mesh query
this.navQuery = new NavMeshQuery(navMesh, 512);
}
public PathQueue(int maxSearchNodeCount, ref TiledNavMesh nav)
{
this.navquery = new NavMeshQuery(nav, maxSearchNodeCount);
this.navqueryfilter = new NavQueryFilter();
this.queue = new PathQuery[MaxQueue];
for (int i = 0; i < MaxQueue; i++)
{
queue[i].Index = 0;
queue[i].Path = new Path();
}
this.queueHead = 0;
}
public PathQueue(int maxPathSize, int maxSearchNodeCount, ref TiledNavMesh nav)
{
this.navquery = new NavMeshQuery(nav, maxSearchNodeCount);
this.maxPathSize = maxPathSize;
this.queue = new PathQuery[MaxQueue];
for (int i = 0; i < MaxQueue; i++)
{
queue[i].Reference = Invalid;
queue[i].Path = new int[maxPathSize];
}
this.queueHead = 0;
}
public PathQueue(int maxPathSize, int maxSearchNodeCount, ref TiledNavMesh nav)
{
this.navquery = new NavMeshQuery(nav, maxSearchNodeCount);
this.maxPathSize = maxPathSize;
this.queue = new PathQuery[MaxQueue];
for (int i = 0; i < MaxQueue; i++)
{
queue[i].Reference = Invalid;
queue[i].Path = new int[maxPathSize];
}
this.queueHead = 0;
}
public PathQueue(int maxSearchNodeCount, ref TiledNavMesh nav)
{
this.navquery = new NavMeshQuery(nav, maxSearchNodeCount);
this.navqueryfilter = new NavQueryFilter();
this.queue = new PathQuery[MaxQueue];
for (int i = 0; i < MaxQueue; i++)
{
queue[i].Index = 0;
queue[i].Path = new Path();
}
this.queueHead = 0;
}
static void GenerateNavMesh(string fileName)
{
NavMeshConfigurationFile file = new NavMeshConfigurationFile();
file.GenerationSettings.AgentRadius = 0.31f;
file.ExportPath = fileName + ".snj";
NavMeshConfigurationFile.MeshSettings loadMesh = new NavMeshConfigurationFile.MeshSettings()
{
Path = fileName + ".obj", Position = new float[3], Scale = 1.0f
};
file.InputMeshes.Add(loadMesh);
List <string> meshes = new List <string>();
List <ObjModel> models = new List <ObjModel>();
foreach (var mesh in file.InputMeshes)
{
//Log.("Path: " + mesh.Path, 2);
//Log.Debug("Scale: " + mesh.Scale, 2);
//Log.Debug("Position: " + mesh.Position.ToString(), 2);
meshes.Add(mesh.Path);
SharpNav.Geometry.Vector3 position = new SharpNav.Geometry.Vector3(mesh.Position[0], mesh.Position[1], mesh.Position[2]);
if (File.Exists(mesh.Path))
{
ObjModel obj = new ObjModel(mesh.Path);
float scale = mesh.Scale;
//TODO SCALE THE OBJ FILE
models.Add(obj);
}
else
{
//Log.Error("Mesh file does not exist.");
return;
}
}
var tris = Enumerable.Empty <SharpNav.Geometry.Triangle3>();
foreach (var model in models)
{
tris = tris.Concat(model.GetTriangles());
}
TiledNavMesh navmesh = NavMesh.Generate(tris, file.GenerationSettings);
new NavMeshJsonSerializer().Serialize(file.ExportPath, navmesh);
}
public static SharpNav.TiledNavMesh LoadNavmesh(TiledNavMesh navmesh, string filePath)
{
SharpNav.IO.NavMeshSerializer serializer;
if (System.IO.Path.GetExtension(filePath) == ".snb")
{
serializer = new SharpNav.IO.Binary.NavMeshBinarySerializer();
}
else
{
serializer = new SharpNav.IO.Json.NavMeshJsonSerializer();
}
return(serializer.Deserialize(System.IO.Path.Combine("../../navmesh/", filePath)));
//return navmesh = new SharpNav.IO.Json.NavMeshJsonSerializer().Deserialize(filePath);
}
public void LoadNavMesh()
{
try
{
tiledNavMesh = new NavMeshJsonSerializer().Deserialize(NavMeshPath);
this.GenDrawMesh();
}
catch (Exception e)
{
Debug.LogError("Navmesh loading failed with exception:" + Environment.NewLine + e.ToString());
return;
}
Debug.Log("LoadNavMesh Done");
}
//private void GenerateNavMesh()
//{
// Console.WriteLine("Generating NavMesh");
// long prevMs = 0;
// try
// {
// var levelTris = level.GetTriangles();
// var triEnumerable = TriangleEnumerable.FromTriangle(levelTris, 0, levelTris.Length);
// BBox3 bounds = triEnumerable.GetBoundingBox();
// settings = NavMeshGenerationSettings.Default;
// heightfield = new Heightfield(bounds, settings);
// heightfield.RasterizeTriangles(levelTris, Area.Default);
// heightfield.FilterLedgeSpans(settings.VoxelAgentHeight, settings.VoxelMaxClimb);
// heightfield.FilterLowHangingWalkableObstacles(settings.VoxelMaxClimb);
// heightfield.FilterWalkableLowHeightSpans(settings.VoxelAgentHeight);
// compactHeightfield = new CompactHeightfield(heightfield, settings);
// compactHeightfield.Erode(settings.VoxelAgentRadius);
// compactHeightfield.BuildDistanceField();
// compactHeightfield.BuildRegions(0, settings.MinRegionSize, settings.MergedRegionSize);
// contourSet = compactHeightfield.BuildContourSet(settings);
// polyMesh = new PolyMesh(contourSet, settings);
// polyMeshDetail = new PolyMeshDetail(polyMesh, compactHeightfield, settings);
// buildData = new NavMeshBuilder(polyMesh, polyMeshDetail, new SharpNav.Pathfinding.OffMeshConnection[0], settings);
// tiledNavMesh = new TiledNavMesh(buildData);
// navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
// }
// catch (Exception e)
// {
// //if (!interceptExceptions)
// // throw;
// //else
// // Console.WriteLine("Navmesh generation failed with exception:" + Environment.NewLine + e.ToString());
// }
// finally
// {
// //sw.Stop();
// }
//}
private void GenerateNavMesh()
{
Console.WriteLine("Generating NavMesh");
long prevMs = 0;
//try
//{
var levelTris = level.GetTriangles();
var triEnumerable = TriangleEnumerable.FromTriangle(levelTris, 0, levelTris.Length);
BBox3 bounds = triEnumerable.GetBoundingBox();
settings = NavMeshGenerationSettings.Default;
heightfield = new Heightfield(bounds, settings);
heightfield.RasterizeTriangles(levelTris, Area.Default);
heightfield.FilterLedgeSpans(settings.VoxelAgentHeight, settings.VoxelMaxClimb);
heightfield.FilterLowHangingWalkableObstacles(settings.VoxelMaxClimb);
heightfield.FilterWalkableLowHeightSpans(settings.VoxelAgentHeight);
compactHeightfield = new CompactHeightfield(heightfield, settings);
compactHeightfield.Erode(settings.VoxelAgentRadius);
compactHeightfield.BuildDistanceField();
compactHeightfield.BuildRegions(0, settings.MinRegionSize, settings.MergedRegionSize);
contourSet = compactHeightfield.BuildContourSet(settings);
polyMesh = new PolyMesh(contourSet, settings);
polyMeshDetail = new PolyMeshDetail(polyMesh, compactHeightfield, settings);
buildData = new NavMeshBuilder(polyMesh, polyMeshDetail, new SharpNav.Pathfinding.OffMeshConnection[0], settings);
tiledNavMesh = new TiledNavMesh(buildData);
navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
OutMesh();
//}
//catch (Exception e)
//{
// //if (!interceptExceptions)
// // throw;
// //else
// // Console.WriteLine("Navmesh generation failed with exception:" + Environment.NewLine + e.ToString());
//}
//finally
//{
// //sw.Stop();
//}
}
public void DestroyNavMesh()
{
//WaitForExecutionAllQueuedOperations();
//lock( nativeLock )
//{
// //!!!!!нужно реально удалить обстаклы?
// foreach( TempObstacle obstacle in tempObstacles )
// {
// obstacle.nativeID = 0;
// obstacle.nativeCreated = false;
// }
//!!!!что-то еще чистить?
// //!!!!надо ли удалять?
// TempObstaclesDestroy();
tiledNavMesh = null;
navMeshQuery = null;
debugNavigationMeshVertices = null;
}
public override TiledNavMesh Deserialize(string path)
{
using (var binaryReader = new BinaryReader(new FileStream(path, FileMode.Open, FileAccess.Read)))
{
byte[] magic = binaryReader.ReadBytes(4);
if (!magic.SequenceEqual(Magic))
{
throw new InvalidDataException("Invalid file magic!");
}
int version = binaryReader.ReadInt32();
if (version != FormatVersion)
{
throw new InvalidDataException("Invalid file version!");
}
var x = binaryReader.ReadSingle();
var y = binaryReader.ReadSingle();
var z = binaryReader.ReadSingle();
var origin = new Vector3(x, y, z);
var tileWidth = binaryReader.ReadSingle();
var tileHeight = binaryReader.ReadSingle();
var maxTiles = (int)binaryReader.ReadSingle();
var maxPolys = (int)binaryReader.ReadSingle();
var tiledNavMesh = new TiledNavMesh(origin, tileWidth, tileHeight, maxTiles, maxPolys);
var navTileCount = binaryReader.ReadInt32();
for (var i = 0; i < navTileCount; i++)
{
NavPolyId baseRef;
var stream = binaryReader.BaseStream;
var tile = DeserializeMeshTile(ref stream, tiledNavMesh.IdManager, out baseRef);
tiledNavMesh.AddTileAt(tile, baseRef);
}
return(tiledNavMesh);
}
}
public override void Serialize(string path, TiledNavMesh mesh)
{
var memoryStream = new MemoryStream();
using (var binaryWriter = new BinaryWriter(memoryStream))
{
binaryWriter.Write(mesh.Origin.X);
binaryWriter.Write(mesh.Origin.Y);
binaryWriter.Write(mesh.Origin.Z);
binaryWriter.Write(mesh.TileWidth);
binaryWriter.Write(mesh.TileHeight);
binaryWriter.Write(mesh.MaxTiles);
binaryWriter.Write(mesh.MaxPolys);
var tiles = new List <byte[]>();
var navTiles = new List <NavTile>(mesh.Tiles);
binaryWriter.Write(navTiles.Count);
foreach (var tile in navTiles)
{
var baseRef = mesh.GetTileRef(tile);
tiles.Add(SerializeMeshTile(tile, baseRef));
}
foreach (var tile in tiles)
{
binaryWriter.Write(tile);
}
}
using (var binaryWriter = new BinaryWriter(new FileStream(path, FileMode.Create, FileAccess.Write)))
{
binaryWriter.Write(Magic);
binaryWriter.Write(FormatVersion);
var tiledNavMesh = memoryStream.ToArray();
binaryWriter.Write(tiledNavMesh);
}
}
public bool MoveOverOffmeshConnection(int offMeshConRef, int[] refs, ref Vector3 startPos, ref Vector3 endPos, NavMeshQuery navquery)
{
//advance the path up to and over the off-mesh connection
int prevRef = 0, polyRef = path[0];
int npos = 0;
while (npos < pathCount && polyRef != offMeshConRef)
{
prevRef = polyRef;
polyRef = path[npos];
npos++;
}
if (npos == pathCount)
{
//could not find offMeshConRef
return(false);
}
//prune path
for (int i = npos; i < pathCount; i++)
{
path[i - npos] = path[i];
}
pathCount -= npos;
refs[0] = prevRef;
refs[1] = polyRef;
TiledNavMesh nav = navquery.NavMesh;
if (nav.GetOffMeshConnectionPolyEndPoints(refs[0], refs[1], ref startPos, ref endPos) == true)
{
pos = endPos;
return(true);
}
return(false);
}
private void LoadNavMeshFromFile(string path)
{
try
{
switch (System.IO.Path.GetExtension(path))
{
case ".snb":
tiledNavMesh = new NavMeshBinarySerializer().Deserialize(path);
break;
case ".snj":
tiledNavMesh = new NavMeshJsonSerializer().Deserialize(path);
break;
default:
throw new NotImplementedException();
}
navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
hasGenerated = true;
displayMode = DisplayMode.NavMesh;
}
catch (Exception e)
{
if (!interceptExceptions)
{
throw;
}
else
{
hasGenerated = false;
tiledNavMesh = null;
navMeshQuery = null;
Console.WriteLine("Navmesh loading failed with exception:" + Environment.NewLine + e.ToString());
}
}
}
private void LoadNavMeshFromFile(string path)
{
try
{
tiledNavMesh = new NavMeshJsonSerializer().Deserialize(path);
navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
hasGenerated = true;
displayMode = DisplayMode.NavMesh;
}
catch (Exception e)
{
if (!interceptExceptions)
{
throw;
}
else
{
hasGenerated = false;
tiledNavMesh = null;
navMeshQuery = null;
Console.WriteLine("Navmesh loading failed with exception:" + Environment.NewLine + e.ToString());
}
}
}
private void DeserializeNavMeshField(JObject root, TiledNavMesh mesh, string fieldName, Type fieldType)
{
JToken token = root.GetValue(fieldName);
if (token != null)
{
var value = token.ToObject(fieldType);
SetPrivateField(mesh, typeof(TiledNavMesh), fieldName, value);
}
}
public override void Serialize(string path, TiledNavMesh mesh)
{
JObject root = new JObject();
root.Add("meta", JToken.FromObject(new
{
version = new
{
snj = FormatVersion,
sharpnav = Assembly.GetExecutingAssembly().GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion
}
}));
root.Add("origin", JToken.FromObject(mesh.Origin, serializer));
root.Add("tileWidth", JToken.FromObject(mesh.TileWidth, serializer));
root.Add("tileHeight", JToken.FromObject(mesh.TileHeight, serializer));
root.Add("maxTiles", JToken.FromObject(mesh.MaxTiles, serializer));
root.Add("maxPolys", JToken.FromObject(mesh.MaxPolys, serializer));
var tilesArray = new JArray();
foreach (NavTile tile in mesh.Tiles)
{
NavPolyId id = mesh.GetTileRef(tile);
tilesArray.Add(SerializeMeshTile(tile, id));
}
root.Add("tiles", tilesArray);
File.WriteAllText(path, root.ToString());
}
public void Load(string path)
{
tiledNavMesh = new NavMeshJsonSerializer().Deserialize(path);
navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
}
public override void Serialize(string path, TiledNavMesh mesh)
{
JObject root = new JObject();
SerializeNavMeshField(root, mesh, "origin");
SerializeNavMeshField(root, mesh, "tileWidth");
SerializeNavMeshField(root, mesh, "tileHeight");
SerializeNavMeshField(root, mesh, "maxTiles");
SerializeNavMeshField(root, mesh, "maxPolys");
SerializeNavMeshField(root, mesh, "tileLookupTableSize");
SerializeNavMeshField(root, mesh, "tileLookupTableMask");
SerializeNavMeshField(root, mesh, "saltBits");
SerializeNavMeshField(root, mesh, "tileBits");
SerializeNavMeshField(root, mesh, "polyBits");
SerializeNavMeshField(root, mesh, "nextFree");
var posLookup = (MeshTile[])GetPrivateField(mesh, typeof(TiledNavMesh), "posLookup");
root.Add("posLookup", SerializeMeshTilesArray(posLookup));
var tiles = (MeshTile[]) GetPrivateField(mesh, typeof(TiledNavMesh), "tiles");
root.Add("tiles", SerializeMeshTilesArray(tiles));
File.WriteAllText(path, root.ToString());
}
public override TiledNavMesh Deserialize(string path)
{
JObject root = JObject.Parse(File.ReadAllText(path));
//TODO error message?
if (root["meta"]["version"]["snj"].ToObject<int>() != FormatVersion)
return null;
Vector3 origin = root["origin"].ToObject<Vector3>(serializer);
float tileWidth = root["tileWidth"].ToObject<float>(serializer);
float tileHeight = root["tileHeight"].ToObject<float>(serializer);
int maxTiles = root["maxTiles"].ToObject<int>(serializer);
int maxPolys = root["maxPolys"].ToObject<int>(serializer);
var mesh = new TiledNavMesh(origin, tileWidth, tileHeight, maxTiles, maxPolys);
JArray tilesToken = (JArray) root["tiles"];
List<MeshTile> tiles = new List<MeshTile>();
foreach (JToken tileToken in tilesToken)
{
mesh.AddTile(DeserializeMeshTile(tileToken, mesh.IdManager, mesh.GetNextTileRef()));
}
return mesh;
}
private void GeneratePathfinding()
{
if (!hasGenerated)
{
return;
}
NavQueryFilter filter = new NavQueryFilter();
buildData = new NavMeshBuilder(polyMesh, polyMeshDetail, new SharpNav.Pathfinding.OffMeshConnection[0], settings);
tiledNavMesh = new TiledNavMesh(buildData);
for (int i = 0; i < tiledNavMesh.Tiles.Count; ++i)
{
for (int j = 0; j < tiledNavMesh.Tiles[i].Verts.Length; ++j)
{
//if (j < tiledNavMesh.Tiles[i].Verts.Length - 1)
// Debug.DrawLine(ExportNavMeshToObj.ToUnityVector(tiledNavMesh.Tiles[i].Verts[j]), ExportNavMeshToObj.ToUnityVector(tiledNavMesh.Tiles[i].Verts[j + 1]), Color.blue, 99);
}
}
navMeshQuery = new NavMeshQuery(tiledNavMesh, 2048);
//Find random start and end points on the poly mesh
/*int startRef;
* navMeshQuery.FindRandomPoint(out startRef, out startPos);*/
//SVector3 c = new SVector3(10, 0, 0);
//SVector3 e = new SVector3(5, 5, 5);
//navMeshQuery.FindNearestPoly(ref c, ref e, out startPt);
//navMeshQuery.FindRandomPointAroundCircle(ref startPt, 1000, out endPt);
startPt = navMeshQuery.FindRandomPoint();
endPt = navMeshQuery.FindRandomPoint();
//calculate the overall path, which contains an array of polygon references
int MAX_POLYS = 256;
path = new Path();
navMeshQuery.FindPath(ref startPt, ref endPt, filter, path);
//find a smooth path over the mesh surface
int npolys = path.Count;
SVector3 iterPos = new SVector3();
SVector3 targetPos = new SVector3();
navMeshQuery.ClosestPointOnPoly(startPt.Polygon, startPt.Position, ref iterPos);
navMeshQuery.ClosestPointOnPoly(path[npolys - 1], endPt.Position, ref targetPos);
smoothPath = new List <SVector3>(2048);
smoothPath.Add(iterPos);
float STEP_SIZE = 0.5f;
float SLOP = 0.01f;
while (npolys > 0 && smoothPath.Count < smoothPath.Capacity)
{
//find location to steer towards
SVector3 steerPos = new SVector3();
StraightPathFlags steerPosFlag = 0;
NavPolyId steerPosRef = NavPolyId.Null;
if (!GetSteerTarget(navMeshQuery, iterPos, targetPos, SLOP, path, ref steerPos, ref steerPosFlag, ref steerPosRef))
{
break;
}
bool endOfPath = (steerPosFlag & StraightPathFlags.End) != 0 ? true : false;
bool offMeshConnection = (steerPosFlag & StraightPathFlags.OffMeshConnection) != 0 ? true : false;
//find movement delta
SVector3 delta = steerPos - iterPos;
float len = (float)Math.Sqrt(SVector3.Dot(delta, delta));
//if steer target is at end of path or off-mesh link
//don't move past location
if ((endOfPath || offMeshConnection) && len < STEP_SIZE)
{
len = 1;
}
else
{
len = STEP_SIZE / len;
}
SVector3 moveTgt = new SVector3();
VMad(ref moveTgt, iterPos, delta, len);
//move
SVector3 result = new SVector3();
List <NavPolyId> visited = new List <NavPolyId>(16);
NavPoint startPoint = new NavPoint(path[0], iterPos);
navMeshQuery.MoveAlongSurface(ref startPoint, ref moveTgt, out result, visited);
path.FixupCorridor(visited);
npolys = path.Count;
float h = 0;
navMeshQuery.GetPolyHeight(path[0], result, ref h);
result.Y = h;
iterPos = result;
//handle end of path when close enough
if (endOfPath && InRange(iterPos, steerPos, SLOP, 1.0f))
{
//reached end of path
iterPos = targetPos;
if (smoothPath.Count < smoothPath.Capacity)
{
smoothPath.Add(iterPos);
}
break;
}
//store results
if (smoothPath.Count < smoothPath.Capacity)
{
smoothPath.Add(iterPos);
}
}
for (int i = 0; i < smoothPath.Count; i++)
{
//if (i < smoothPath.Count - 1)
// Debug.DrawLine(ExportNavMeshToObj.ToUnityVector(smoothPath[i]), ExportNavMeshToObj.ToUnityVector(smoothPath[i + 1]), Color.red, 99);
}
}
private void SerializeNavMeshField(JObject root, TiledNavMesh mesh, string fieldName)
{
var field = GetPrivateField(mesh, typeof(TiledNavMesh), fieldName);
if (field != null)
{
root.Add(fieldName, JToken.FromObject(field, serializer));
}
}
