public override void DrawWindow()
{
if (BehaviorEditor.currentGraph == null)
{
EditorGUILayout.LabelField("Add graph to modify:");
}
BehaviorEditor.currentGraph = (BehaviourGraph)EditorGUILayout.ObjectField(BehaviorEditor.currentGraph, typeof(BehaviourGraph), false);
if (BehaviorEditor.currentGraph == null)
{
if (previousGraph != null)
{
previousGraph = null;
}
EditorGUILayout.LabelField("No graph assigned");
return;
}
if (previousGraph != BehaviorEditor.currentGraph)
{
previousGraph = BehaviorEditor.currentGraph;
}
}
public void Load(BehaviourGraph graph)
{
if (graph == null)
{
return;
}
_graph = graph;
DeleteElements(edges.ToList());
DeleteElements(nodes.ToList());
Properties.Clear();
Blackboard.Clear();
foreach (var variable in graph.Variables)
{
AddExposedProperty(new ExposedProperty
{
Name = variable.Name,
Type = variable.Type,
IsGlobal = variable.IsGlobal
});
}
NodeDeserializer.Deserialize(graph.BehaviorSource.TaskData, this);
}
public void Save(BehaviourGraph graph)
{
graph.Links.Clear();
if (graph == null)
{
return;
}
foreach (var edge in edges.ToList())
{
var inputNode = edge.input.node as TaskNode;
var outputNode = edge.output.node as TaskNode;
graph.Links.Add(new NodeLink
{
SourceGuid = outputNode.GUID,
TargetGuid = inputNode.GUID
});
}
graph.NodesData.Clear();
foreach (var node in nodes.ToList().Cast <TaskNode>())
{
graph.NodesData.Add(new NodeData
{
GUID = node.GUID,
Position = node.GetPosition().position,
Type = node.Type,
Data = node.Data
});
}
var id = 0;
var entry = graph.NodesData.FirstOrDefault(x => x.Type == typeof(EntryTask));
if (entry != null)
{
AssignID(entry, ref id);
}
graph.Variables.Clear();
foreach (var variable in Properties)
{
graph.Variables.Add(new Variable
{
Name = variable.Name,
Type = variable.Type,
IsGlobal = variable.IsGlobal
});
}
graph.BehaviorSource.TaskData = NodeSerializer.Serialize(graph);
EditorUtility.SetDirty(graph);
AssetDatabase.SaveAssets();
}
/// <summary>
/// A bootstrap hack to create a root node on creation.
/// </summary>
public override void OnCreate()
{
BehaviourGraph bg = target as BehaviourGraph;
Debug.Assert(bg != null, nameof(bg) + " != null");
bg.EditorTimeInitialization();
base.OnCreate();
}
public void OpenGraph(BehaviourGraph openGraph)
{
targetGraph = openGraph;
dragging_Position = Vector2.zero;
ResetView();
Repaint();
}
private void DrawTopBar()
{
EditorGUILayout.BeginHorizontal(EditorStyles.toolbar, GUILayout.ExpandWidth(true));
if (GUILayout.Button("Load Graph", EditorStyles.toolbarButton, GUILayout.Width(100)))
{
controlID = GUIUtility.GetControlID(FocusType.Passive);
EditorGUIUtility.ShowObjectPicker <BehaviourGraph> (targetGraph, false, "", controlID);
}
string commandName = currentEvent.commandName;
if (commandName == "ObjectSelectorUpdated")
{
Repaint();
}
else if (commandName == "ObjectSelectorClosed")
{
if (EditorGUIUtility.GetObjectPickerControlID() == controlID)
{
BehaviourGraph nextGraph = EditorGUIUtility.GetObjectPickerObject() as BehaviourGraph;
if (nextGraph == null)
{
// CloseGraph ();
}
else
{
if (targetGraph != nextGraph)
{
OpenGraph(nextGraph.GetInstanceID(), 0);
}
}
return;
}
}
GUILayout.Space(5.0f);
EditorGUI.BeginDisabledGroup(targetGraph == null);
if (GUILayout.Button("Goto Asset", EditorStyles.toolbarButton, GUILayout.Width(100)))
{
EditorUtility.FocusProjectWindow();
EditorGUIUtility.PingObject(targetGraph);
}
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Screenshot", EditorStyles.toolbarButton, GUILayout.Width(100)))
{
screenshot_TakeScreenshot = true;
Repaint();
EditorApplication.delayCall += Repaint;
}
EditorGUILayout.EndHorizontal();
}
protected override void Init()
{
if (initialized)
{
return;
}
parentGraph = graph as BehaviourGraph;
UnityEngine.Debug.Assert(parentGraph != null, nameof(parentGraph) + " != null");
initialized = true;
OnCreation();
}
private static JToken SerializeVariables(BehaviourGraph graph)
{
var ret = new JArray();
foreach (var variable in graph.Variables)
{
if (variable.IsGlobal)
{
continue;
}
var instance = Activator.CreateInstance(variable.Type) as SharedVariable;
instance.Name = variable.Name;
instance.IsShared = true;
ret.Add(JToken.FromObject(instance, Serializer));
}
return(ret);
}
private void HandleDragAndDrop(Rect dropArea)
{
if (dropArea.Contains(Event.current.mousePosition))
{
if (!IsValidImport(DragAndDrop.objectReferences))
{
// DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
return;
}
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (Event.current.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
{
object importObject = DragAndDrop.objectReferences[i];
if (importObject.GetType() == typeof(MonoScript))
{
MonoScript monoScriptImport = (MonoScript)importObject;
Type monoScriptType = monoScriptImport.GetClass();
if (monoScriptType != null &&
typeof(BehaviourNode).IsAssignableFrom(monoScriptType))
{
AddNodeCallback(monoScriptType, Event.current.mousePosition);
}
}
else if (typeof(BehaviourGraph).IsAssignableFrom(importObject.GetType()))
{
BehaviourGraph graphImport = (BehaviourGraph)importObject;
OpenGraph(graphImport);
}
}
}
}
}
private static JToken SerializeNode(BehaviourGraph graph, NodeData node, List <UnityEngine.Object> objects, bool withChildren = true)
{
if (node == null)
{
return(null);
}
var obj = new JObject();
obj.Add("Type", JToken.FromObject(EvaluateType(node.Type), Serializer));
obj.Add("ID", JToken.FromObject(node.Data.ID, Serializer));
obj.Add("Name", JToken.FromObject(node.Data.FriendlyName, Serializer));
obj.Add("Instant", JToken.FromObject(node.Data.IsInstant, Serializer));
obj.Add("NodeData", new JObject
{
["Offset"] = JToken.FromObject(node.Position, Serializer)
});
WriteFields(node.Type, node.Data, obj, graph, objects);
if (!withChildren)
{
return(obj);
}
var children = graph.GetLinked(node).ToList();
if (children.Count > 0)
{
var array = new JArray();
foreach (var child in children)
{
array.Add(SerializeNode(graph, child, objects));
}
obj.Add("Children", array);
}
return(obj);
}
public BehaviourGraphView(EditorWindow window, BehaviourGraph graph)
{
SetupZoom(ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale);
this.AddManipulator(new ContentDragger());
this.AddManipulator(new SelectionDragger());
this.AddManipulator(new RectangleSelector());
this.AddManipulator(new FreehandSelector());
graphViewChanged = OnGraphViewChanged;
_graph = graph;
_searchWindow = ScriptableObject.CreateInstance <NodeSearchWindow>();
_searchWindow.Init(window, this);
nodeCreationRequest = context =>
SearchWindow.Open(new SearchWindowContext(context.screenMousePosition), _searchWindow);
_inspectorObject = ScriptableObject.CreateInstance <InspectorObject>();
_inspectorObject.name = "Node Inspector";
_inspectorObject.hideFlags = HideFlags.HideAndDontSave ^ HideFlags.NotEditable;
_inspectorObject.View = this;
Properties = new List <ExposedProperty>();
RegisterCallback <MouseUpEvent>(OnMouseUp);
RegisterCallback <MouseDownEvent>(OnMouseDown);
RegisterCallback <KeyDownEvent>(OnKeyDown);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/GraphView"));
Insert(0, new GridBackground());
Undo.undoRedoPerformed += UpdateInspectorSelection;
}
public static TaskSerializationData Serialize(BehaviourGraph graph)
{
var data = new TaskSerializationData();
var entry = graph.NodesData.FirstOrDefault(x => x.Type == typeof(EntryTask));
if (entry == null)
{
Debug.LogWarning($"Graph {AssetDatabase.GetAssetPath(graph)} has no Entry node and will be left empty");
return(data);
}
var nodes = graph.GetLinked(entry);
var root = nodes.FirstOrDefault();
var objects = new List <UnityEngine.Object>();
var node = new JObject
{
{ "EntryTask", SerializeNode(graph, entry, objects, false) },
{ "RootTask", SerializeNode(graph, root, objects) },
{ "Variables", SerializeVariables(graph) }
};
var sb = new StringBuilder();
Serializer.Serialize(new StringWriter(sb), node);
data.JSONSerialization = sb.ToString();
data.Version = "1.5.7";
data.fieldSerializationData = new FieldSerializationData {
unityObjects = objects
};
return(data);
}
public void CloseGraph()
{
targetGraph = null;
}
private static void WriteFields(Type type, object target, JObject obj, BehaviourGraph graph, List <UnityEngine.Object> objects)
{
foreach (var field in GetSerializedFields(type))
{
try
{
var value = field.GetValue(target);
if (value is SharedVariable shared)
{
var variable = graph.Variables.FirstOrDefault(x => x.Name == shared.Name);
if (variable != null)
{
shared.IsGlobal = variable.IsGlobal;
}
var sValue = shared.GetValue();
if (sValue is UnityEngine.Object sObject)
{
var idx = objects.FindIndex(x => ReferenceEquals(x, sObject));
if (idx == -1)
{
objects.Add(sObject);
idx = objects.FindIndex(x => ReferenceEquals(x, sObject));
}
shared.PropertyMapping = idx.ToString();
}
}
else if (value is UnityEngine.Object sObject)
{
var idx = objects.FindIndex(x => ReferenceEquals(x, sObject));
if (idx == -1)
{
objects.Add(sObject);
idx = objects.FindIndex(x => ReferenceEquals(x, sObject));
}
obj.Add(field.FieldType.Name + field.Name, JToken.FromObject(idx, Serializer));
continue;
}
else if (IsTaskReference(field.FieldType))
{
if (field.FieldType.IsArray)
{
var array = value as Array;
var idx = new List <int>();
for (var i = 0; i < array.Length; i++)
{
value = array.GetValue(i);
var task = graph.NodesData.FirstOrDefault(x => x.Data == value);
if (task != null)
{
idx.Add(task.Data.ID);
}
}
obj.Add(field.FieldType.Name + field.Name, JToken.FromObject(idx, Serializer));
}
else
{
var task = graph.NodesData.FirstOrDefault(x => x.Data == value);
if (task != null)
{
obj.Add(field.FieldType.Name + field.Name, JToken.FromObject(task.Data.ID, Serializer));
}
}
continue;
}
var name = field.FieldType.Name + field.Name;
if (HasConverter.Any(x => x.IsAssignableFrom(field.FieldType)))
{
if (value != null && !obj.ContainsKey(name))
{
obj.Add(name, JToken.FromObject(value, Serializer));
}
}
else if (value != null)
{
if (field.FieldType.IsPrimitive || field.FieldType == typeof(string) || field.FieldType.IsEnum)
{
obj.Add(name, JToken.FromObject(value, Serializer));
}
else
{
var container = new JObject();
WriteFields(field.FieldType, value, container, graph, objects);
obj.Add(name, container);
}
}
}
catch (Exception e)
{
Debug.Log(e);
}
}
}
