/** Deserializes graphs from the specified byte array.
* If an error ocurred, it will try to deserialize using the old deserializer.
* A warning will be logged if all deserializers failed.
*/
public void DeserializeGraphs(byte[] bytes)
{
try {
if (bytes != null)
{
Pathfinding.Serialization.AstarSerializer sr = new Pathfinding.Serialization.AstarSerializer(this);
if (sr.OpenDeserialize(bytes))
{
DeserializeGraphsPart(sr);
sr.CloseDeserialize();
}
else
{
Debug.Log("Invalid data file (cannot read zip). Trying to load with old deserializer (pre 3.1)...");
AstarSerializer serializer = new AstarSerializer(active);
DeserializeGraphs_oldInternal(serializer);
}
}
else
{
throw new System.ArgumentNullException("Bytes should not be null when passed to DeserializeGraphs");
}
active.DataUpdate();
} catch (System.Exception e) {
Debug.LogWarning("Caught exception while deserializing data.\n" + e);
data_backup = bytes;
}
}
/** Deserializes graphs from the specified byte array additively.
* An error will be logged if deserialization fails.
* This function will add loaded graphs to the current ones.
*/
public void DeserializeGraphsAdditive(byte[] bytes)
{
var graphLock = AssertSafe();
try {
if (bytes != null)
{
var sr = new AstarSerializer();
if (sr.OpenDeserialize(bytes))
{
DeserializeGraphsPartAdditive(sr);
sr.CloseDeserialize();
}
else
{
Debug.Log("Invalid data file (cannot read zip).\nThe data is either corrupt or it was saved using a 3.0.x or earlier version of the system");
}
}
else
{
throw new System.ArgumentNullException("bytes");
}
AstarPath.active.VerifyIntegrity();
} catch (System.Exception e) {
Debug.LogError("Caught exception while deserializing data.\n" + e);
graphs = new NavGraph[0];
}
UpdateShortcuts();
graphLock.Release();
}
/** \copydoc Pathfinding::ISerializableObject::DeSerializeSettings */
public void DeSerializeSettings(AstarSerializer serializer)
{
mask.value = (int)serializer.GetValue("Mask", typeof(int));
diameter = (float)serializer.GetValue("Diameter", typeof(float));
height = (float)serializer.GetValue("Height", typeof(float));
type = (ColliderType)serializer.GetValue("Type", typeof(int));
rayDirection = (RayDirection)serializer.GetValue("RayDirection", typeof(int));
heightMask.value = (int)serializer.GetValue("heightMask", typeof(int), -1);
fromHeight = (float)serializer.GetValue("fromHeight", typeof(float), 100.0F);
thickRaycastDiameter = (float)serializer.GetValue("thickRaycastDiameter", typeof(float));
thickRaycast = (bool)serializer.GetValue("thickRaycast", typeof(bool));
collisionCheck = (bool)serializer.GetValue("collisionCheck", typeof(bool), true);
heightCheck = (bool)serializer.GetValue("heightCheck", typeof(bool), true);
unwalkableWhenNoGround = (bool)serializer.GetValue("unwalkableWhenNoGround", typeof(bool), true);
collisionOffset = (float)serializer.GetValue("collisionOffset", typeof(float), 0.0F);
if (fromHeight == 0)
{
fromHeight = 100;
}
}
public void DeSerializeSettings(AstarSerializer serializer)
{
System.IO.BinaryReader stream = serializer.readerStream;
offset = (Vector3)serializer.GetValue("offset", typeof(Vector3));
rotation = (Vector3)serializer.GetValue("rotation", typeof(Vector3));
scale = (float)serializer.GetValue("scale", typeof(float));
GenerateMatrix();
Vector3[] verts = new Vector3[stream.ReadInt32()];
int[] tris = new int[stream.ReadInt32()];
for (int i = 0; i < verts.Length; i++)
{
verts[i] = new Vector3(stream.ReadSingle(), stream.ReadSingle(), stream.ReadSingle());
}
for (int i = 0; i < tris.Length; i++)
{
tris[i] = stream.ReadInt32();
}
sourceMesh = serializer.GetUnityReferenceValue("sourceMesh", typeof(Mesh)) as Mesh;
if (Application.isPlaying)
{
sourceMesh = new Mesh();
sourceMesh.name = "NavGraph Mesh";
sourceMesh.vertices = verts;
sourceMesh.triangles = tris;
}
}
public void DeSerializeSettings(AstarSerializer serializer)
{
//erosionRadius = (int)serializer.GetValue ("erosionRadius",typeof(int));
contourMaxError = (float)serializer.GetValue("contourMaxError", typeof(float));
cellSize = (float)serializer.GetValue("cellSize", typeof(float));
cellHeight = (float)serializer.GetValue("cellHeight", typeof(float));
walkableHeight = (float)serializer.GetValue("walkableHeight", typeof(float));
walkableClimb = (float)serializer.GetValue("walkableClimb", typeof(float));
maxSlope = (float)serializer.GetValue("maxSlope", typeof(float));
maxEdgeLength = (float)serializer.GetValue("maxEdgeLength", typeof(float));
forcedBoundsCenter = (Vector3)serializer.GetValue("forcedBoundsCenter", typeof(Vector3));
forcedBoundsSize = (Vector3)serializer.GetValue("forcedBoundsSize", typeof(Vector3));
mask.value = (int)serializer.GetValue("mask", typeof(int));
showMeshOutline = (bool)serializer.GetValue("showMeshOutline", typeof(bool));
includeOutOfBounds = (bool)serializer.GetValue("includeOutOfBounds", typeof(bool));
regionMinSize = (int)serializer.GetValue("regionMinSize", typeof(int));
characterRadius = (float)serializer.GetValue("characterRadius", typeof(float));
useCRecast = (bool)serializer.GetValue("useCRecast", typeof(bool));
}
public void SerializeSettings(AstarSerializer serializer)
{
//serializer.AddValue ("erosionRadius",erosionRadius);
serializer.AddValue("contourMaxError", contourMaxError);
serializer.AddValue("cellSize", cellSize);
serializer.AddValue("cellHeight", cellHeight);
serializer.AddValue("walkableHeight", walkableHeight);
serializer.AddValue("walkableClimb", walkableClimb);
serializer.AddValue("maxSlope", maxSlope);
serializer.AddValue("maxEdgeLength", maxEdgeLength);
serializer.AddValue("forcedBoundsCenter", forcedBoundsCenter);
serializer.AddValue("forcedBoundsSize", forcedBoundsSize);
serializer.AddValue("mask", mask.value);
serializer.AddValue("showMeshOutline", showMeshOutline);
serializer.AddValue("includeOutOfBounds", includeOutOfBounds);
serializer.AddValue("regionMinSize", regionMinSize);
serializer.AddValue("characterRadius", characterRadius);
serializer.AddValue("useCRecast", useCRecast);
}
/** Deserializes common info.
* Common info is what is shared between the editor serialization and the runtime serializer.
* This is mostly everything except the graph inspectors which serialize some extra data in the editor
*/
public void DeserializeGraphsPart(AstarSerializer sr)
{
ClearGraphs();
graphs = sr.DeserializeGraphs();
if (graphs != null)
{
for (var i = 0; i < graphs.Length; i++)
{
if (graphs[i] != null)
{
graphs[i].graphIndex = (uint)i;
}
}
}
userConnections = sr.DeserializeUserConnections();
//sr.DeserializeNodes();
sr.DeserializeExtraInfo();
//Assign correct graph indices.
for (var i = 0; i < graphs.Length; i++)
{
if (graphs[i] == null)
{
continue;
}
graphs[i].GetNodes(delegate(GraphNode node) {
node.GraphIndex = (uint)i;
return(true);
});
}
sr.PostDeserialization();
}
/** Deserializes graphs from the specified byte array.
* If an error occured, it will try to deserialize using the old deserializer.
* A warning will be logged if all deserializers failed.
*/
public void DeserializeGraphs(byte[] bytes)
{
AstarPath.active.BlockUntilPathQueueBlocked();
try {
if (bytes != null)
{
var sr = new AstarSerializer(this);
if (sr.OpenDeserialize(bytes))
{
DeserializeGraphsPart(sr);
sr.CloseDeserialize();
UpdateShortcuts();
}
else
{
Debug.Log("Invalid data file (cannot read zip).\nThe data is either corrupt or it was saved using a 3.0.x or earlier version of the system");
}
}
else
{
throw new ArgumentNullException("Bytes should not be null when passed to DeserializeGraphs");
}
active.VerifyIntegrity();
} catch (Exception e) {
Debug.LogWarning("Caught exception while deserializing data.\n" + e);
data_backup = bytes;
}
}
public void DeserializeGraphsAdditive(byte[] bytes)
{
AstarPath.active.BlockUntilPathQueueBlocked();
try
{
if (bytes == null)
{
throw new ArgumentNullException("bytes");
}
AstarSerializer astarSerializer = new AstarSerializer(this);
if (astarSerializer.OpenDeserialize(bytes))
{
this.DeserializeGraphsPartAdditive(astarSerializer);
astarSerializer.CloseDeserialize();
}
else
{
Debug.Log("Invalid data file (cannot read zip).");
}
AstarData.active.VerifyIntegrity();
}
catch (Exception arg)
{
Debug.LogWarning("Caught exception while deserializing data.\n" + arg);
}
}
public void DeserializeGraphsPart(AstarSerializer sr)
{
this.ClearGraphs();
this.graphs = sr.DeserializeGraphs();
if (this.graphs != null)
{
for (int j = 0; j < this.graphs.Length; j++)
{
if (this.graphs[j] != null)
{
this.graphs[j].graphIndex = (uint)j;
}
}
}
this.userConnections = sr.DeserializeUserConnections();
sr.DeserializeExtraInfo();
int i;
for (i = 0; i < this.graphs.Length; i++)
{
if (this.graphs[i] != null)
{
this.graphs[i].GetNodes(delegate(GraphNode node)
{
node.GraphIndex = (uint)i;
return(true);
});
}
}
sr.PostDeserialization();
}
public void SerializeGraphsPart(AstarSerializer sr)
{
sr.SerializeGraphs(this.graphs);
sr.SerializeUserConnections(this.userConnections);
sr.SerializeNodes();
sr.SerializeExtraInfo();
}
//These functions are for serialization, the static ones are there so other graphs using mesh nodes can serialize them more easily
public static void SerializeMeshNodes(INavmesh graph, Node[] nodes, AstarSerializer serializer)
{
System.IO.BinaryWriter stream = serializer.writerStream;
for (int i = 0; i < nodes.Length; i++)
{
MeshNode node = nodes[i] as MeshNode;
if (node == null)
{
Debug.LogError("Serialization Error : Couldn't cast the node to the appropriate type - NavMeshGenerator");
return;
}
stream.Write(node.v1);
stream.Write(node.v2);
stream.Write(node.v3);
}
Int3[] vertices = graph.vertices;
if (vertices == null)
{
vertices = new Int3[0];
}
stream.Write(vertices.Length);
for (int i = 0; i < vertices.Length; i++)
{
stream.Write(vertices[i].x);
stream.Write(vertices[i].y);
stream.Write(vertices[i].z);
}
}
public void DeserializeGraphs(byte[] bytes)
{
AstarPath.active.BlockUntilPathQueueBlocked();
try
{
if (bytes == null)
{
throw new ArgumentNullException("bytes");
}
AstarSerializer astarSerializer = new AstarSerializer(this);
if (astarSerializer.OpenDeserialize(bytes))
{
this.DeserializeGraphsPart(astarSerializer);
astarSerializer.CloseDeserialize();
this.UpdateShortcuts();
}
else
{
Debug.Log("Invalid data file (cannot read zip).\nThe data is either corrupt or it was saved using a 3.0.x or earlier version of the system");
}
AstarData.active.VerifyIntegrity();
}
catch (Exception arg)
{
Debug.LogWarning("Caught exception while deserializing data.\n" + arg);
this.data_backup = bytes;
}
}
public void DeserializeGraphsAdditive(byte[] bytes)
{
PathProcessor.GraphUpdateLock graphUpdateLock = this.AssertSafe(false);
try
{
if (bytes == null)
{
throw new ArgumentNullException("bytes");
}
AstarSerializer astarSerializer = new AstarSerializer(this);
if (astarSerializer.OpenDeserialize(bytes))
{
this.DeserializeGraphsPartAdditive(astarSerializer);
astarSerializer.CloseDeserialize();
}
else
{
Debug.Log("Invalid data file (cannot read zip).\nThe data is either corrupt or it was saved using a 3.0.x or earlier version of the system");
}
AstarData.active.VerifyIntegrity();
}
catch (Exception arg)
{
Debug.LogError("Caught exception while deserializing data.\n" + arg);
this.graphs = new NavGraph[0];
this.data_backup = bytes;
}
this.UpdateShortcuts();
graphUpdateLock.Release();
}
public static void DeSerializeMeshNodes(INavmesh graph, Node[] nodes, AstarSerializer serializer)
{
System.IO.BinaryReader stream = serializer.readerStream;
for (int i = 0; i < nodes.Length; i++)
{
MeshNode node = nodes[i] as MeshNode;
if (node == null)
{
Debug.LogError("Serialization Error : Couldn't cast the node to the appropriate type - NavMeshGenerator");
return;
}
node.v1 = stream.ReadInt32();
node.v2 = stream.ReadInt32();
node.v3 = stream.ReadInt32();
}
int numVertices = stream.ReadInt32();
graph.vertices = new Int3[numVertices];
for (int i = 0; i < numVertices; i++)
{
int x = stream.ReadInt32();
int y = stream.ReadInt32();
int z = stream.ReadInt32();
graph.vertices[i] = new Int3(x, y, z);
}
RebuildBBTree(graph as NavGraph);
}
/** Deserializes serialization info. Deserializes Version, mask and #loadedGraphGuids
* \see OpenDeserialize */
public AstarSerializer DeserializeSerializationInfo()
{
if (!MoveToAnchor("SerializerSettings"))
{
throw (new System.NullReferenceException("Anchor SerializerSettings was not found in the data"));
}
BinaryReader stream = readerStream;
System.Version astarVersion = null;
try {
astarVersion = new Version(stream.ReadString());
}
catch (Exception e) {
Debug.LogError("Couldn't parse A* version ");
error = SerializerError.WrongVersion;
throw new System.FormatException("Couldn't parse A* version", e);
}
//System.Version astarVersion2 = AstarPath.Version;
AstarSerializer returnSerializer = this;
if (!IgnoreVersionDifferences)
{
if (astarVersion > AstarPath.Version)
{
Debug.LogError("Loading graph saved with a newer version of the A* Pathfinding Project, trying to load, but you might get errors.\nFile version: " + astarVersion + " Current A* version: " + AstarPath.Version);
//error = SerializerError.WrongVersion;
//return;
}
else if (astarVersion != AstarPath.Version)
{
Debug.LogWarning("Loading graphs saved with an older version of the A* Pathfinding Project, trying to load.\nFile version: " + astarVersion + " Current A* version: " + AstarPath.Version);
//Copy this serializer's loaded values to the new serializer
returnSerializer = new AstarSerializer3_01(active);
returnSerializer.readerStream = readerStream;
returnSerializer.anchors = anchors;
}
}
int count = stream.ReadInt32();
//@Fix - Look up existing graph first
returnSerializer.loadedGraphGuids = new string[count];
for (int i = 0; i < count; i++)
{
returnSerializer.loadedGraphGuids[i] = stream.ReadString();
//loadedGraphGuids[i] = i;
}
returnSerializer.mask = stream.ReadInt32();
return(returnSerializer);
}
public void DeserializeGraphsPart(AstarSerializer sr)
{
PathProcessor.GraphUpdateLock graphUpdateLock = this.AssertSafe(false);
this.ClearGraphs();
this.DeserializeGraphsPartAdditive(sr);
graphUpdateLock.Release();
}
public void DeserializeGraphsAdditive(byte[] bytes)
{
AstarPath.active.BlockUntilPathQueueBlocked();
try
{
if (bytes == null)
{
throw new ArgumentNullException("Bytes should not be null when passed to DeserializeGraphs");
}
AstarSerializer sr = new AstarSerializer(this);
if (sr.OpenDeserialize(bytes))
{
this.DeserializeGraphsPartAdditive(sr);
sr.CloseDeserialize();
}
else
{
Debug.Log("Invalid data file (cannot read zip).");
}
this.active.VerifyIntegrity();
}
catch (Exception exception)
{
Debug.LogWarning("Caught exception while deserializing data.\n" + exception);
}
}
public void SaveCacheData(int mask)
{
AstarSerializer serializer = new AstarSerializer(active);
serializer.mask = mask; //AstarSerializer.SaveNodes;
data_cachedStartup = SerializeGraphs(serializer);
cacheStartup = true;
}
public void DeserializeGraphsPartAdditive(AstarSerializer sr)
{
if (this.graphs == null)
{
this.graphs = new NavGraph[0];
}
if (this.userConnections == null)
{
this.userConnections = new UserConnection[0];
}
List <NavGraph> list = new List <NavGraph>(this.graphs);
list.AddRange(sr.DeserializeGraphs());
this.graphs = list.ToArray();
if (this.graphs != null)
{
for (int l = 0; l < this.graphs.Length; l++)
{
if (this.graphs[l] != null)
{
this.graphs[l].graphIndex = (uint)l;
}
}
}
List <UserConnection> list2 = new List <UserConnection>(this.userConnections);
list2.AddRange(sr.DeserializeUserConnections());
this.userConnections = list2.ToArray();
sr.DeserializeNodes();
DebugHelper.Assert(this.graphs != null, "不能为空");
int i;
for (i = 0; i < this.graphs.Length; i++)
{
if (this.graphs[i] != null)
{
this.graphs[i].GetNodes(delegate(GraphNode node)
{
node.GraphIndex = (uint)i;
return(true);
});
}
}
sr.DeserializeExtraInfo();
sr.PostDeserialization();
for (int j = 0; j < this.graphs.Length; j++)
{
for (int k = j + 1; k < this.graphs.Length; k++)
{
if (this.graphs[j] != null && this.graphs[k] != null && this.graphs[j].guid == this.graphs[k].guid)
{
Debug.LogWarning("Guid Conflict when importing graphs additively. Imported graph will get a new Guid.\nThis message is (relatively) harmless.");
this.graphs[j].guid = Guid.NewGuid();
break;
}
}
}
}
public byte[] SerializeGraphs(SerializeSettings settings, out uint checksum)
{
AstarPath.active.BlockUntilPathQueueBlocked();
AstarSerializer astarSerializer = new AstarSerializer(this, settings);
astarSerializer.OpenSerialize();
this.SerializeGraphsPart(astarSerializer);
byte[] result = astarSerializer.CloseSerialize();
checksum = astarSerializer.GetChecksum();
return(result);
}
public byte[] SerializeGraphsExtra(SerializeSettings settings)
{
AstarPath.active.BlockUntilPathQueueBlocked();
AstarSerializer astarSerializer = new AstarSerializer(this, settings);
astarSerializer.OpenSerialize();
astarSerializer.graphs = this.graphs;
byte[] result = astarSerializer.SerializeExtraInfoBytes();
astarSerializer.CloseSerialize();
return(result);
}
//End Serialization Settings
/** Loads the graphs from memory, will load cached graphs if any exists */
public void Awake()
{
if (cacheStartup && data_cachedStartup != null)
{
LoadFromCache();
}
else
{
AstarSerializer serializer = new AstarSerializer(active);
DeserializeGraphs(serializer);
}
}
public void DeSerializeSettings(AstarSerializer serializer)
{
root = (Transform)serializer.GetUnityReferenceValue("root", typeof(Transform));
maxDistance = (float)serializer.GetValue("maxDistance", typeof(float));
limits = (Vector3)serializer.GetValue("limits", typeof(Vector3));
mask.value = (int)serializer.GetValue("mask", typeof(int));
thickRaycast = (bool)serializer.GetValue("thickRaycast", typeof(bool));
thickRaycastRadius = (float)serializer.GetValue("thickRaycastRadius", typeof(float));
searchTag = (string)serializer.GetValue("searchTag", typeof(string));
recursive = (bool)serializer.GetValue("recursive", typeof(bool));
}
public void LoadFromCache()
{
if (data_cachedStartup != null && data_cachedStartup.Length > 0)
{
AstarSerializer serializer = new AstarSerializer(active);
DeserializeGraphs(serializer, data_cachedStartup);
}
else
{
Debug.LogError("Can't load from cache since the cache is empty");
}
}
public byte[] SerializeGraphs(SerializeSettings settings, out uint checksum)
{
PathProcessor.GraphUpdateLock graphUpdateLock = this.AssertSafe(false);
AstarSerializer astarSerializer = new AstarSerializer(this, settings);
astarSerializer.OpenSerialize();
this.SerializeGraphsPart(astarSerializer);
byte[] result = astarSerializer.CloseSerialize();
checksum = astarSerializer.GetChecksum();
graphUpdateLock.Release();
return(result);
}
//End Serialization Settings
/** Loads the graphs from memory, will load cached graphs if any exists */
public void Awake () {
if (cacheStartup && data_cachedStartup != null) {
LoadFromCache ();
} else {
AstarSerializer serializer = new AstarSerializer (active);
DeserializeGraphs (serializer);
}
}
public void SerializeSettings(AstarSerializer serializer)
{
;
serializer.AddUnityReferenceValue("root", root);
serializer.AddValue("maxDistance", maxDistance);
serializer.AddValue("limits", limits);
serializer.AddValue("mask", mask.value);
serializer.AddValue("thickRaycast", thickRaycast);
serializer.AddValue("thickRaycastRadius", thickRaycastRadius);
serializer.AddValue("searchTag", searchTag);
serializer.AddValue("recursive", recursive);
}
/** Main serializer function, a similar one exists in the AstarEditor.cs script to save additional info */
public byte[] SerializeGraphs(AstarSerializer serializer)
{
serializer.OpenSerialize();
SerializeGraphsPart(serializer);
serializer.Close();
byte[] bytes = (serializer.writerStream.BaseStream as System.IO.MemoryStream).ToArray();
Debug.Log("Got a whole bunch of data, " + bytes.Length + " bytes");
return(bytes);
}
/** Main serializer function.
* Serializes all graphs to a byte array
* A similar function exists in the AstarPathEditor.cs script to save additional info */
public byte[] SerializeGraphs(SerializeSettings settings, out uint checksum)
{
AstarPath.active.BlockUntilPathQueueBlocked();
var sr = new AstarSerializer(this, settings);
sr.OpenSerialize();
SerializeGraphsPart(sr);
var bytes = sr.CloseSerialize();
checksum = sr.GetChecksum();
return(bytes);
}
/** Saves all graphs and also user connections, but does not close, nor opens the stream */
public void SerializeGraphsPart(AstarSerializer serializer)
{
//AstarSerializer serializer = new AstarSerializer ();
//serializer.OpenSerializeSettings ();
SizeProfiler.Initialize();
SizeProfiler.Begin("File", serializer.writerStream, false);
SizeProfiler.Begin("Graphs init", serializer.writerStream);
serializer.writerStream.Write(graphs.Length);
serializer.writerStream.Write(graphs.Length);
SizeProfiler.End("Graphs init", serializer.writerStream);
int[] masks = new int[graphs.Length];
for (int i = 0; i < graphs.Length; i++)
{
NavGraph graph = graphs[i];
int tmpMask = serializer.mask;
SizeProfiler.Begin("Graphs type " + i, serializer.writerStream);
serializer.AddAnchor("Graph" + i);
serializer.writerStream.Write(graph.GetType().Name);
serializer.writerStream.Write(graph.guid.ToString());
SizeProfiler.Begin("Graphs settings " + i, serializer.writerStream);
//Set an unique prefix for all variables in this graph
serializer.sPrefix = i.ToString();
serializer.SerializeSettings(graph, active);
serializer.sPrefix = "";
masks[i] = serializer.mask;
serializer.mask = tmpMask;
SizeProfiler.End("Graphs settings " + i, serializer.writerStream);
}
SizeProfiler.Begin("User Connections", serializer.writerStream);
serializer.SerializeUserConnections(userConnections);
SizeProfiler.End("User Connections", serializer.writerStream);
//data = (serializer.writerStream.BaseStream as System.IO.MemoryStream).ToArray ();
//serializer.Close ();
SizeProfiler.End("File", serializer.writerStream);
SizeProfiler.Log();
}
public void SerializeSettings (NavGraph target, AstarSerializer serializer) {
//NavMeshGraph graph = target as NavMeshGraph;
//string meshPath = AssetDatabase.GetAssetPath (graph.sourceMesh);
//string meshGUID = AssetDatabase.AssetPathToGUID (meshPath);
/*if (graph == null) {
serializer.writerStream.Write (-1);
} else {
int instanceID = graph.sourceMesh != null ? graph.sourceMesh.GetInstanceID () : -1;
serializer.writerStream.Write (instanceID);
}*/
}
public void DeSerializeSettings (NavGraph target, AstarSerializer serializer) {
//NavMeshGraph graph = target as NavMeshGraph;
//string meshGUID = serializer.readerStream.ReadString ();
//int instanceID = serializer.readerStream.ReadInt32 ();
//Mesh ob = EditorUtility.InstanceIDToObject (instanceID) as Mesh;
//if (!Application.isPlaying) {
//graph.sourceMesh = ob;
/*string meshPath = AssetDatabase.GUIDToAssetPath (meshGUID);
Debug.Log (meshGUID +" "+ meshPath);
graph.sourceMesh = AssetDatabase.LoadAssetAtPath (meshPath,typeof(Mesh)) as Mesh;*/
//}
//Debug.Log ("Did succeed? "+(graph.sourceMesh != null));
}
public static void WriteUnityReference (AstarSerializer serializer, UnityEngine.Object ob) {
if (ob == null) {
serializer.writerStream.Write ("");
serializer.writerStream.Write ("");
return;
}
string assetPath = AssetDatabase.GetAssetPath (ob);
if (assetPath != "") {
string guid = AssetDatabase.AssetPathToGUID (assetPath);
serializer.writerStream.Write (guid);
} else {
serializer.writerStream.Write ("");
}
}
public void DeSerializeSettings (AstarSerializer serializer) {
root = (Transform)serializer.GetUnityReferenceValue ("root",typeof(Transform));
maxDistance = (float)serializer.GetValue ("maxDistance",typeof(float));
limits = (Vector3)serializer.GetValue ("limits",typeof(Vector3));
mask.value = (int)serializer.GetValue ("mask",typeof(int));
thickRaycast = (bool)serializer.GetValue ("thickRaycast",typeof(bool));
thickRaycastRadius = (float)serializer.GetValue ("thickRaycastRadius",typeof(float));
searchTag = (string)serializer.GetValue ("searchTag",typeof(string));
recursive = (bool)serializer.GetValue ("recursive",typeof(bool));
raycast = (bool)serializer.GetValue ("raycast",typeof(bool),true);
}
public void DeSerializeNodes (Node[] nodes, AstarSerializer serializer) {
//NavMeshGraph.DeSerializeMeshNodes (this as INavmesh, nodes, serializer);
}
public new void SerializeSettings(AstarSerializer serializer)
{
(this as GridGraph).SerializeSettings (serializer);
serializer.AddValue ("mergeSpanRange",mergeSpanRange);
serializer.AddValue ("characterHeight",characterHeight);
//serializer.AddValue ("maxClimb",maxClimb);
}
public void DeSerializeSettings(AstarSerializer serializer)
{
//width = (int)serializer.GetValue ("Width",typeof(int));
//depth = (int)serializer.GetValue ("Depth",typeof(int));
//height = (float)serializer.GetValue ("Height",typeof(float));
unclampedSize = (Vector2)serializer.GetValue ("unclampedSize",typeof(Vector2));
cutCorners = (bool)serializer.GetValue ("cutCorners",typeof(bool));
neighbours = (NumNeighbours)serializer.GetValue ("neighbours",typeof(int));
rotation = (Vector3)serializer.GetValue ("rotation",typeof(Vector3));
nodeSize = (float)serializer.GetValue ("nodeSize",typeof(float));
collision = (GraphCollision)serializer.GetValue ("collision",typeof(GraphCollision));
center = (Vector3)serializer.GetValue ("center",typeof(Vector3));
maxClimb = (float)serializer.GetValue ("maxClimb",typeof(float));
maxClimbAxis = (int)serializer.GetValue ("maxClimbAxis",typeof(int),1);
maxSlope = (float)serializer.GetValue ("maxSlope",typeof(float),90.0F);
erodeIterations = (int)serializer.GetValue ("erodeIterations",typeof(int));
penaltyAngle = (bool)serializer.GetValue ("penaltyAngle",typeof(bool));
penaltyAngleFactor = (float)serializer.GetValue ("penaltyAngleFactor",typeof(float));
penaltyPosition = (bool)serializer.GetValue ("penaltyPosition",typeof(bool));
penaltyPositionOffset = (float)serializer.GetValue ("penaltyPositionOffset",typeof(float));
penaltyPositionFactor = (float)serializer.GetValue ("penaltyPositionFactor",typeof(float));
aspectRatio = (float)serializer.GetValue ("aspectRatio",typeof(float),1F);
textureData = serializer.GetValue ("textureData",typeof(TextureData)) as TextureData;
if (textureData == null) textureData = new TextureData ();
#if UNITY_EDITOR
Matrix4x4 oldMatrix = matrix;
#endif
GenerateMatrix ();
SetUpOffsetsAndCosts ();
#if UNITY_EDITOR
if (serializer.onlySaveSettings) {
if (oldMatrix != matrix && nodes != null) {
AstarPath.active.AutoScan ();
}
}
#endif
//Debug.Log ((string)serializer.GetValue ("SomeString",typeof(string)));
//Debug.Log ((Bounds)serializer.GetValue ("SomeBounds",typeof(Bounds)));
}
public void SerializeSettings(AstarSerializer serializer)
{
serializer.AddUnityReferenceValue ("source",source);
serializer.AddValue ("enabled",enabled);
for (int i=0;i<factors.Length;i++) {
serializer.AddValue ("factor"+i,factors[i]);
}
for (int i=0;i<channels.Length;i++) {
serializer.AddValue ("channel"+i,(int)channels[i]);
}
}
/** Serialize Settings.
* \deprecated This function is obsolete. New serialization functions exist */
public void SerializeSettings(AstarSerializer serializer)
{
serializer.mask -= AstarSerializer.SMask.SaveNodePositions;
//serializer.AddValue ("Width",width);
//serializer.AddValue ("Depth",depth);
//serializer.AddValue ("Height",height);
serializer.AddValue ("unclampedSize",unclampedSize);
serializer.AddValue ("cutCorners",cutCorners);
serializer.AddValue ("neighbours",(int)neighbours);
serializer.AddValue ("center",center);
serializer.AddValue ("rotation",rotation);
serializer.AddValue ("nodeSize",nodeSize);
serializer.AddValue ("collision",collision == null ? new GraphCollision () : collision);
serializer.AddValue ("maxClimb",maxClimb);
serializer.AddValue ("maxClimbAxis",maxClimbAxis);
serializer.AddValue ("maxSlope",maxSlope);
serializer.AddValue ("erodeIterations",erodeIterations);
serializer.AddValue ("penaltyAngle",penaltyAngle);
serializer.AddValue ("penaltyAngleFactor",penaltyAngleFactor);
serializer.AddValue ("penaltyPosition",penaltyPosition);
serializer.AddValue ("penaltyPositionOffset",penaltyPositionOffset);
serializer.AddValue ("penaltyPositionFactor",penaltyPositionFactor);
serializer.AddValue ("aspectRatio",aspectRatio);
serializer.AddValue ("textureData",textureData);
}
/** Deserializes all graphs and also user connections \deprecated */
public void DeserializeGraphsPart(AstarSerializer serializer)
{
if (serializer.error != AstarSerializer.SerializerError.Nothing) {
data_backup = (serializer.readerStream.BaseStream as System.IO.MemoryStream).ToArray ();
Debug.Log ("Error encountered : "+serializer.error+"\nWriting data to AstarData.data_backup");
graphs = new NavGraph[0];
return;
}
try {
int count1 = serializer.readerStream.ReadInt32 ();
int count2 = serializer.readerStream.ReadInt32 ();
if (count1 != count2) {
Debug.LogError ("Data is corrupt ("+count1 +" != "+count2+")");
graphs = new NavGraph[0];
return;
}
NavGraph[] _graphs = new NavGraph[count1];
//graphs = new NavGraph[count1];
for (int i=0;i<_graphs.Length;i++) {
if (!serializer.MoveToAnchor ("Graph"+i)) {
Debug.LogError ("Couldn't find graph "+i+" in the data");
Debug.Log ("Logging... "+serializer.anchors.Count);
foreach (KeyValuePair<string,int> value in serializer.anchors) {
Debug.Log ("KeyValuePair "+value.Key);
}
_graphs[i] = null;
continue;
}
string graphType = serializer.readerStream.ReadString ();
graphType = graphType.Replace ("ListGraph","PointGraph");
Guid guid = new Guid (serializer.readerStream.ReadString ());
//Search for existing graphs with the same GUID. If one is found, that means that we are loading another version of that graph
//Use that graph then and just load it with some new settings
NavGraph existingGraph = GuidToGraph (guid);
if (existingGraph != null) {
_graphs[i] = existingGraph;
//Replace
//graph.guid = new System.Guid ();
//serializer.loadedGraphGuids[i] = graph.guid.ToString ();
} else {
_graphs[i] = CreateGraph (graphType);
}
NavGraph graph = _graphs[i];
if (graph == null) {
Debug.LogError ("One of the graphs saved was of an unknown type, the graph was of type '"+graphType+"'");
data_backup = data;
graphs = new NavGraph[0];
return;
}
_graphs[i].guid = guid;
//Set an unique prefix for all variables in this graph
serializer.sPrefix = i.ToString ();
serializer.DeSerializeSettings (graph,active);
}
serializer.SetUpGraphRefs (_graphs);
for (int i=0;i<_graphs.Length;i++) {
NavGraph graph = _graphs[i];
if (serializer.MoveToAnchor ("GraphNodes_Graph"+i)) {
serializer.mask = serializer.readerStream.ReadInt32 ();
serializer.sPrefix = i.ToString ()+"N";
serializer.DeserializeNodes (graph,_graphs,i,active);
serializer.sPrefix = "";
}
//Debug.Log ("Graph "+i+" has loaded "+(graph.nodes != null ? graph.nodes.Length.ToString () : "null")+" nodes");
}
userConnections = serializer.DeserializeUserConnections ();
//Remove null graphs
List<NavGraph> tmp = new List<NavGraph>(_graphs);
for (int i=0;i<_graphs.Length;i++) {
if (_graphs[i] == null) {
tmp.Remove (_graphs[i]);
}
}
graphs = tmp.ToArray ();
} catch (System.Exception e) {
data_backup = (serializer.readerStream.BaseStream as System.IO.MemoryStream).ToArray ();
Debug.LogWarning ("Deserializing Error Encountered - Writing data to AstarData.data_backup:\n"+e.ToString ());
graphs = new NavGraph[0];
return;
}
}
public void DeserializeGraphs(AstarSerializer serializer, byte[] bytes)
{
DeserializeGraphs_oldInternal (serializer, bytes);
}
/** Deserializes graphs from the specified byte array.
* If an error ocurred, it will try to deserialize using the old deserializer.
* A warning will be logged if all deserializers failed.
*/
public void DeserializeGraphs(byte[] bytes)
{
try {
if (bytes != null) {
Pathfinding.Serialize.AstarSerializer sr = new Pathfinding.Serialize.AstarSerializer(this);
if (sr.OpenDeserialize(bytes)) {
DeserializeGraphsPart (sr);
sr.CloseDeserialize();
} else {
Debug.Log ("Invalid data file (cannot read zip). Trying to load with old deserializer (pre 3.1)...");
AstarSerializer serializer = new AstarSerializer (active);
DeserializeGraphs_oldInternal (serializer);
}
} else {
throw new System.ArgumentNullException ("Bytes should not be null when passed to DeserializeGraphs");
}
active.DataUpdate ();
} catch (System.Exception e) {
Debug.LogWarning ("Caught exception while deserializing data.\n"+e);
data_backup = bytes;
}
}
public void DeSerializationInterrupt (AstarSerializer serializer, bool isNewer, System.Guid g1) {
if (EditorUtility.DisplayDialog ("Replace Graph?","Another version of this graph already exists. Do you want to replace it?","Replace","Add")) {
serializer.replaceOldGraphs = true;
} else {
serializer.replaceOldGraphs = false;
}
}
/** \copydoc Pathfinding::ISerializableObject::SerializeSettings \copybrief Pathfinding::ISerializableObject::SerializeSettings */
public void SerializeSettings(AstarSerializer serializer)
{
serializer.AddValue ("Mask",(int)mask);
serializer.AddValue ("Diameter",diameter);
serializer.AddValue ("Height",height);
serializer.AddValue ("Type",(int)type);
serializer.AddValue ("RayDirection",(int)rayDirection);
serializer.AddValue ("heightMask",(int)heightMask);
serializer.AddValue ("fromHeight",fromHeight);
serializer.AddValue ("thickRaycastDiameter",thickRaycastDiameter);
serializer.AddValue ("thickRaycast",thickRaycast);
serializer.AddValue ("collisionCheck",collisionCheck);
serializer.AddValue ("heightCheck",heightCheck);
serializer.AddValue ("unwalkableWhenNoGround",unwalkableWhenNoGround);
serializer.AddValue ("collisionOffset",collisionOffset);
}
/*public void OnDisableUndo () {
return;
if (!editor.enableUndo) {
return;
}
if (undoState != null) {
ScriptableObject.DestroyImmediate (undoState);
undoState = null;
}
}
private void ApplyUndo () {
return;
if (!editor.enableUndo) {
return;
}
undoState.hasBeenReverted = false;
if (AstarPath.active == null) {
return;
}
byte[] bytes = GetSerializedBytes (target);
bool isDifferent = false;
//Check if the data is any different from the last saved data, if it isn't, don't load it
if (undoState.data == null || bytes.Length != undoState.data.Length) {
isDifferent = true;
} else {
for (int i=0;i<bytes.Length;i++) {
if (bytes[i] != undoState.data[i]) {
isDifferent = true;
break;
}
}
}
if (isDifferent) {
Debug.Log ("The undo is different "+ Event.current.type +" "+Event.current.commandName);
//Event.current.Use ();
AstarSerializer sz = new AstarSerializer (editor.script);
sz.OpenDeserialize (undoState.data);
sz.DeSerializeSettings (target,AstarPath.active);
sz.Close ();
}
}
public void ModifierKeysChanged () {
return;
if (!editor.enableUndo) {
return;
}
if (undoState == null) {
return;
}
//The user has tried to undo something, apply that
if (undoState.hasBeenReverted) {
ApplyUndo ();
GUI.changed = true;
editor.Repaint ();
}
}
/** Handles undo operations for the graph *
public void HandleUndo (NavGraph target) {
return;
if (!editor.enableUndo) {
return;
}
if (undoState == null) {
undoState = ScriptableObject.CreateInstance<GraphUndo>();
}
Event e = Event.current;
//ModifierKeysChanged ();
//To serialize settings for a grid graph takes from 0.00 ms to 7.8 ms (usually 0.0, but sometimes jumps up to 7.8 (no values in between)
if ((e.button == 0 && (e.type == EventType.MouseDown || e.type == EventType.MouseUp)) || (e.isKey && (e.keyCode == KeyCode.Tab || e.keyCode == KeyCode.Return))) {
System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
//Serialize the settings of the graph
byte[] bytes = GetSerializedBytes (target);
bool isDifferent = false;
if (undoState.data == null) {
Debug.LogError ("UndoState.data == null - This should not happen");
return;
}
//Check if the data is any different from the last saved data, if it isn't, don't save it
if (bytes.Length != undoState.data.Length) {
isDifferent = true;
} else {
for (int i=0;i<bytes.Length;i++) {
if (bytes[i] != undoState.data[i]) {
isDifferent = true;
break;
}
}
}
//Only save undo if the data was different from the last saved undo
if (isDifferent) {
//This flag is set to true so we can detect if the object has been reverted
undoState.hasBeenReverted = true;
Undo.RegisterUndo (undoState,"A* inspector");
//Assign the new data
undoState.data = bytes;
//Undo.SetSnapshotTarget(undoState,"A* inspector");
//Undo.CreateSnapshot ();
//Undo.RegisterSnapshot();
undoState.hasBeenReverted = false;
Debug.Log ("Saved "+bytes.Length+" bytes");
stopWatch.Stop();
Debug.Log ("Adding Undo "+stopWatch.Elapsed.ToString ());
}
}
}*/
/** Returns a byte array with the settings of the graph. This function serializes the graph's settings and stores them in a byte array, used for undo operations. This will not save any additional metadata such as which A* version we are working on. */
private byte[] GetSerializedBytes(NavGraph target)
{
//Serialize the settings of the graph
AstarSerializer sz = new AstarSerializer (editor.script);
sz.OpenSerialize ();
sz.SerializeSettings (target,AstarPath.active);
sz.Close ();
byte[] bytes = (sz.writerStream.BaseStream as System.IO.MemoryStream).ToArray ();
return bytes;
}
public void SerializeNodes(Node[] nodes, AstarSerializer serializer)
{
/** \todo Add check for mask == Save Node Positions. Can't use normal mask since it is changed by SerializeSettings */
GenerateMatrix ();
int maxValue = 0;
int minValue = 0;
for (int i=0;i<nodes.Length;i++) {
int val = nodes[i].position.y;
maxValue = val > maxValue ? val : maxValue;
minValue = val < minValue ? val : minValue;
}
int maxRange = maxValue > -minValue ? maxValue : -minValue;
if (maxRange <= System.Int16.MaxValue) {
//Int16
serializer.writerStream.Write ((byte)0);
for (int i=0;i<nodes.Length;i++) {
serializer.writerStream.Write ((System.Int16)(inverseMatrix.MultiplyPoint3x4 ((Vector3)nodes[i].position).y));
}
} else {
//Int32
serializer.writerStream.Write ((byte)1);
for (int i=0;i<nodes.Length;i++) {
serializer.writerStream.Write (inverseMatrix.MultiplyPoint3x4 ((Vector3)nodes[i].position).y);
}
}
/*for (int i=0;i<nodes.Length;i++) {
GridNode node = nodes[i] as GridNode;
if (node == null) {
Debug.LogError ("Serialization Error : Couldn't cast the node to the appropriate type - GridGenerator");
return;
}
serializer.writerStream.Write (node.index);
}*/
}
/** Main deserializer function (old), loads from the #data variable \deprecated */
public void DeserializeGraphs_oldInternal(AstarSerializer serializer)
{
DeserializeGraphs_oldInternal (serializer, data);
}
public void DeSerializeSettings(AstarSerializer serializer)
{
enabled = (bool)serializer.GetValue ("enabled",typeof(bool));
source = (Texture2D)serializer.GetUnityReferenceValue ("source",typeof(Texture2D));
factors = new float[3];
for (int i=0;i<factors.Length;i++) {
factors[i] = (float)serializer.GetValue ("factor"+i,typeof(float),1F);
}
channels = new ChannelUse[3];
for (int i=0;i<channels.Length;i++) {
channels[i] = (ChannelUse)serializer.GetValue ("channel"+i,typeof(int));
}
}
/** Main deserializer function (old). Loads from \a bytes variable \deprecated */
public void DeserializeGraphs_oldInternal(AstarSerializer serializer, byte[] bytes)
{
System.DateTime startTime = System.DateTime.UtcNow;
if (bytes == null || bytes.Length == 0) {
Debug.Log ("No previous data, assigning default");
graphs = new NavGraph[0];
return;
}
Debug.Log ("Deserializing...");
serializer = serializer.OpenDeserialize (bytes);
DeserializeGraphsPart (serializer);
serializer.Close ();
System.DateTime endTime = System.DateTime.UtcNow;
Debug.Log ("Deserialization complete - Process took "+((endTime-startTime).Ticks*0.0001F).ToString ("0.00")+" ms");
}
public void DeSerializeNodes(Node[] nodes, AstarSerializer serializer)
{
/*for (int i=0;i<nodes.Length;i++) {
GridNode node = nodes[i] as GridNode;
if (node == null) {
Debug.LogError ("DeSerialization Error : Couldn't cast the node to the appropriate type - GridGenerator");
return;
}*/
GenerateMatrix ();
SetUpOffsetsAndCosts ();
if (nodes == null || nodes.Length == 0) {
return;
}
nodes = new GridNode[nodes.Length];
int gridIndex = GridNode.SetGridGraph (this);
int numberSize = (int)serializer.readerStream.ReadByte ();
for (int z = 0; z < depth; z ++) {
for (int x = 0; x < width; x++) {
GridNode node = nodes[z*width+x] as GridNode;
nodes[z*width+x] = node;
if (node == null) {
Debug.LogError ("DeSerialization Error : Couldn't cast the node to the appropriate type - GridGenerator");
return;
}
node.SetIndex (z*width+x);
node.SetGridIndex (gridIndex);
float yPos = 0;
//if (serializer.mask == AstarSerializer.SMask.SaveNodePositions) {
//Needs to multiply with precision factor because the position will be scaled by Int3.Precision later (Vector3 --> Int3 conversion)
if (numberSize == 0) {
yPos = serializer.readerStream.ReadInt16 ();
} else {
yPos = serializer.readerStream.ReadInt32 ();
}
//}
node.position = (Int3)matrix.MultiplyPoint3x4 (new Vector3 (x+0.5F,yPos,z+0.5F));
}
}
}
//These functions are for serialization, the static ones are there so other graphs using mesh nodes can serialize them more easily
public static void SerializeMeshNodes (INavmesh graph, Node[] nodes, AstarSerializer serializer) {
System.IO.BinaryWriter stream = serializer.writerStream;
for (int i=0;i<nodes.Length;i++) {
MeshNode node = nodes[i] as MeshNode;
if (node == null) {
Debug.LogError ("Serialization Error : Couldn't cast the node to the appropriate type - NavMeshGenerator");
return;
}
stream.Write (node.v1);
stream.Write (node.v2);
stream.Write (node.v3);
}
Int3[] vertices = graph.vertices;
if (vertices == null) {
vertices = new Int3[0];
}
stream.Write (vertices.Length);
for (int i=0;i<vertices.Length;i++) {
stream.Write (vertices[i].x);
stream.Write (vertices[i].y);
stream.Write (vertices[i].z);
}
}
public static void DeSerializeMeshNodes (INavmesh graph, Node[] nodes, AstarSerializer serializer) {
System.IO.BinaryReader stream = serializer.readerStream;
for (int i=0;i<nodes.Length;i++) {
MeshNode node = nodes[i] as MeshNode;
if (node == null) {
Debug.LogError ("Serialization Error : Couldn't cast the node to the appropriate type - NavMeshGenerator");
return;
}
node.v1 = stream.ReadInt32 ();
node.v2 = stream.ReadInt32 ();
node.v3 = stream.ReadInt32 ();
}
int numVertices = stream.ReadInt32 ();
graph.vertices = new Int3[numVertices];
for (int i=0;i<numVertices;i++) {
int x = stream.ReadInt32 ();
int y = stream.ReadInt32 ();
int z = stream.ReadInt32 ();
graph.vertices[i] = new Int3 (x,y,z);
}
RebuildBBTree (graph as NavGraph);
}
public void SerializeSettings (AstarSerializer serializer) {
System.IO.BinaryWriter stream = serializer.writerStream;
serializer.AddValue ("offset",offset);
serializer.AddValue ("rotation",rotation);
serializer.AddValue ("scale",scale);
if (sourceMesh != null) {
Vector3[] verts = sourceMesh.vertices;
int[] tris = sourceMesh.triangles;
stream.Write (verts.Length);
stream.Write (tris.Length);
for (int i=0;i<verts.Length;i++) {
stream.Write (verts[i].x);
stream.Write (verts[i].y);
stream.Write (verts[i].z);
}
for (int i=0;i<tris.Length;i++) {
stream.Write (tris[i]);
}
} else {
stream.Write (0);
stream.Write (0);
}
serializer.AddUnityReferenceValue ("sourceMesh",sourceMesh);
}
public new void DeSerializeSettings(AstarSerializer serializer)
{
(this as GridGraph).DeSerializeSettings (serializer);
mergeSpanRange = (float)serializer.GetValue ("mergeSpanRange",typeof(float),mergeSpanRange);
characterHeight = (float)serializer.GetValue ("characterHeight",typeof(float),characterHeight);
//maxClimb = (float)serializer.GetValue ("maxClimb",typeof(float),maxClimb);
}
public void DeSerializeSettings (AstarSerializer serializer) {
System.IO.BinaryReader stream = serializer.readerStream;
offset = (Vector3)serializer.GetValue ("offset",typeof(Vector3));
rotation = (Vector3)serializer.GetValue ("rotation",typeof(Vector3));
scale = (float)serializer.GetValue ("scale",typeof(float));
GenerateMatrix ();
Vector3[] verts = new Vector3[stream.ReadInt32 ()];
int[] tris = new int[stream.ReadInt32 ()];
for (int i=0;i<verts.Length;i++) {
verts[i] = new Vector3(stream.ReadSingle (),stream.ReadSingle (),stream.ReadSingle ());
}
for (int i=0;i<tris.Length;i++) {
tris[i] = stream.ReadInt32 ();
}
sourceMesh = serializer.GetUnityReferenceValue ("sourceMesh",typeof(Mesh)) as Mesh;
if (Application.isPlaying) {
sourceMesh = new Mesh ();
sourceMesh.name = "NavGraph Mesh";
sourceMesh.vertices = verts;
sourceMesh.triangles = tris;
}
}
public void SerializeSettings (AstarSerializer serializer) {;
serializer.AddUnityReferenceValue ("root",root);
serializer.AddValue ("maxDistance",maxDistance);
serializer.AddValue ("limits",limits);
serializer.AddValue ("mask",mask.value);
serializer.AddValue ("thickRaycast",thickRaycast);
serializer.AddValue ("thickRaycastRadius",thickRaycastRadius);
serializer.AddValue ("searchTag",searchTag);
serializer.AddValue ("recursive",recursive);
serializer.AddValue ("raycast",raycast);
}
public void DeSerializeSettings (NavGraph target, AstarSerializer serializer) {
pivot = (GridPivot)serializer.GetValue ("pivot",typeof(int),GridPivot.BottomLeft);
locked = (bool)serializer.GetValue ("locked",typeof(bool),true);
showExtra = (bool)serializer.GetValue ("showExtra",typeof(bool));
}
/** \copydoc Pathfinding::ISerializableObject::DeSerializeSettings */
public void DeSerializeSettings(AstarSerializer serializer)
{
mask.value = (int)serializer.GetValue ("Mask",typeof (int));
diameter = (float)serializer.GetValue ("Diameter",typeof (float));
height = (float)serializer.GetValue ("Height",typeof (float));
type = (ColliderType)serializer.GetValue ("Type",typeof(int));
rayDirection = (RayDirection)serializer.GetValue ("RayDirection",typeof(int));
heightMask.value = (int)serializer.GetValue ("heightMask",typeof (int),-1);
fromHeight = (float)serializer.GetValue ("fromHeight",typeof (float), 100.0F);
thickRaycastDiameter = (float)serializer.GetValue ("thickRaycastDiameter",typeof (float));
thickRaycast = (bool)serializer.GetValue ("thickRaycast",typeof (bool));
collisionCheck = (bool)serializer.GetValue ("collisionCheck",typeof(bool),true);
heightCheck = (bool)serializer.GetValue ("heightCheck",typeof(bool),true);
unwalkableWhenNoGround = (bool)serializer.GetValue ("unwalkableWhenNoGround",typeof(bool),true);
collisionOffset = (float)serializer.GetValue ("collisionOffset",typeof(float),0.0F);
if (fromHeight == 0) fromHeight = 100;
}
public static UnityEngine.Object ReadUnityReference (AstarSerializer serializer, string name, int instanceID, System.Type type) {
Object ob1 = EditorUtility.InstanceIDToObject (instanceID);
//Discard if not the correct type
if (ob1 != null && !type.IsAssignableFrom (ob1.GetType ())) {
ob1 = null;
}
Object ob2 = null;
if (ob1 != null && ob1.name == name) {
//Debug.Log ("Loading from InstanceID + name");
return ob1;
}
string guid = serializer.readerStream.ReadString ();
if (guid != "") {
string path = AssetDatabase.GUIDToAssetPath (guid);
ob2 = AssetDatabase.LoadMainAssetAtPath (path);
//Discard if not the correct type
if (ob2 != null && !type.IsAssignableFrom (ob2.GetType ())) {
ob2 = null;
}
//Debug.Log ("Got path "+path+" Got Object "+(ob2 != null));
if (ob2 != null) {
if (ob2 == ob1) {
return ob2;
}
if (ob2.name == name) {
return ob2;
}
}
}
//If any were found, return them in priority order
if (ob2 != null) {
return ob2;
}
if (ob1 != null) {
return ob1;
}
return null;
}