/*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; }