/*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 static NavGraph[] Load(string filePath)
{
byte[] bytes = AstarSerializer.LoadFromFile(filePath);
AstarSerializer sr = new AstarSerializer();
if (!sr.OpenDeserialize(bytes))
{
throw new Exception("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");
}
var gr = new List <NavGraph>();
// Set an offset so that the deserializer will load
// the graphs with the correct graph indexes
sr.SetGraphIndexOffset(gr.Count);
gr.AddRange(sr.DeserializeGraphs());
NavGraph[] graphs = gr.ToArray();
sr.DeserializeEditorSettingsCompatibility();
sr.DeserializeExtraInfo();
//Assign correct graph indices.
for (int i = 0; i < graphs.Length; i++)
{
if (graphs[i] == null)
{
continue;
}
int i1 = i;
graphs[i].GetNodes(node => node.GraphIndex = (uint)i1);
}
for (int i = 0; i < graphs.Length; i++)
{
for (int j = i + 1; j < graphs.Length; j++)
{
if (graphs[i] != null && graphs[j] != null && graphs[i].guid == graphs[j].guid)
{
graphs[i].guid = Guid.NewGuid();
break;
}
}
}
sr.PostDeserialization();
sr.CloseDeserialize();
return(graphs);
}
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 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));
}
public void SerializeSettings(NavGraph target, AstarSerializer serializer)
{
serializer.AddValue("pivot", (int)pivot);
serializer.AddValue("locked", locked);
serializer.AddValue("showExtra", showExtra);
}
public static NavGraph[] Load(string filePath)
{
byte[] bytes = AstarSerializer.LoadFromFile(filePath);
return(Load(bytes));
}
/** Deserializes common info additively
* 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 DeserializeGraphsPartAdditive (AstarSerializer sr) {
if (graphs == null) graphs = new NavGraph[0];
if (userConnections == null) userConnections = new UserConnection[0];
var gr = new List<NavGraph>(graphs);
gr.AddRange (sr.DeserializeGraphs ());
graphs = gr.ToArray();
if ( graphs != null ) for ( var i = 0; i<graphs.Length;i++ ) if ( graphs[i] != null ) graphs[i].graphIndex = (uint)i;
var conns = new List<UserConnection>(userConnections);
conns.AddRange (sr.DeserializeUserConnections());
userConnections = conns.ToArray ();
sr.DeserializeNodes();
//Assign correct graph indices. Issue #21
for (var i=0;i<graphs.Length;i++) {
if (graphs[i] == null) continue;
graphs[i].GetNodes (delegate (GraphNode node) {
//GraphNode[] nodes = graphs[i].nodes;
node.GraphIndex = (uint)i;
return true;
});
}
sr.DeserializeExtraInfo();
sr.PostDeserialization();
for (var i=0;i<graphs.Length;i++) {
for (var j=i+1;j<graphs.Length;j++) {
if (graphs[i] != null && graphs[j] != null && graphs[i].guid == graphs[j].guid) {
Debug.LogWarning ("Guid Conflict when importing graphs additively. Imported graph will get a new Guid.\nThis message is (relatively) harmless.");
graphs[i].guid = Guid.NewGuid ();
break;
}
}
}
}
/** 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 additively.
* If an error ocurred, it will try to deserialize using the old deserializer.
* A warning will be logged if all deserializers failed.
* This function will add loaded graphs to the current ones
*/
public void DeserializeGraphsAdditive (byte[] bytes) {
AstarPath.active.BlockUntilPathQueueBlocked();
try {
if (bytes != null) {
var sr = new AstarSerializer(this);
if (sr.OpenDeserialize(bytes)) {
DeserializeGraphsPartAdditive (sr);
sr.CloseDeserialize();
} else {
Debug.Log ("Invalid data file (cannot read zip).");
}
} 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);
}
}
/** 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;
}
}
/** Serializes common info to the serializer.
* 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 SerializeGraphsPart (AstarSerializer sr) {
sr.SerializeGraphs(graphs);
sr.SerializeUserConnections (userConnections);
sr.SerializeNodes();
sr.SerializeExtraInfo();
}
/** 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;
}
