private GraphViewChange SendPortChangeEvents(GraphViewChange change)
{
change.edgesToCreate?.ForEach(edge =>
{
if (edge.input?.userData is IPortUpdater inputUpdater)
{
inputUpdater.OnConnect(edge.input, edge);
}
if (edge.output?.userData is IPortUpdater outputUpdater)
{
outputUpdater.OnConnect(edge.output, edge);
}
});
var edges = change.elementsToRemove?.OfType <Edge>();
if (edges != null)
{
foreach (var edge in edges)
{
if (edge.input?.userData is IPortUpdater inputUpdater)
{
inputUpdater.OnDisconnect(edge.input, edge);
}
if (edge.output?.userData is IPortUpdater outputUpdater)
{
outputUpdater.OnDisconnect(edge.output, edge);
}
}
}
return(change);
}
GraphViewChange OnGraphViewChanged(GraphViewChange change)
{
removingElement.Clear();
if (change.elementsToRemove != null)
{
removingElement.UnionWith(change.elementsToRemove);
}
foreach (GraphElement element in change.movedElements ?? Enumerable.Empty <GraphElement>())
{
if (!(element is TreeGraphNode node))
{
continue;
}
node.RecalculateOrder();
}
foreach (GraphElement element in change.elementsToRemove ?? Enumerable.Empty <GraphElement>())
{
var port = (element as Edge)?.input;
var node = (port == null ? element : port.node) as TreeGraphNode;
if (port != null)
{
removingElement.Add(node);
}
node?.RecalculateOrder();
}
return(change);
}
public IEnumerator DeletingGraphElementsExecutesElementDeletedDelegate()
{
bool elementDeleted = false;
graphView.graphViewChanged += graphViewChange =>
{
elementDeleted = (graphViewChange.elementsToRemove.Count == 1);
return(graphViewChange);
};
Node node1 = CreateNode("", new Rect(50, 50, 50, 50));
yield return(null);
GraphViewChange change = new GraphViewChange {
elementsToRemove = new List <GraphElement> {
node1
}
};
window.graphView.graphViewChanged(change);
yield return(null);
Assert.IsTrue(elementDeleted);
yield return(null);
}
private GraphViewChange UpdateModel(GraphViewChange change)
{
var movedNodes = change.movedElements?.OfType <IBehaviourGraphNode>();
if (movedNodes != null)
{
foreach (var movedElement in movedNodes)
{
var entry = movedElement.Model.Entries.Find(entry => entry != null && entry?.Id == ((Node)movedElement).viewDataKey);
if (entry != null)
{
entry.Layout = ((Node)movedElement).GetPosition();
}
}
}
var removedNodes = change.elementsToRemove?.OfType <IBehaviourGraphNode>();
if (removedNodes != null)
{
foreach (var removedElement in removedNodes)
{
var index = removedElement.Model.Entries.FindIndex(entry => entry != null && entry?.Id == ((Node)removedElement).viewDataKey);
if (index > 0)
{
removedElement.Model.Entries[index] = null;
}
}
}
return(change);
}
GraphViewChange GraphViewChangedCallback(GraphViewChange changes)
{
if (changes.elementsToRemove != null)
{
RegisterCompleteObjectUndo("Remove Graph Elements");
//Handle ourselves the edge and node remove
changes.elementsToRemove.RemoveAll(e => {
var edge = e as EdgeView;
var node = e as BaseNodeView;
var commentBlock = e as CommentBlockView;
if (edge != null)
{
Disconnect(edge);
return(true);
}
else if (node != null)
{
graph.RemoveNode(node.nodeTarget);
RemoveElement(node);
return(true);
}
else if (commentBlock != null)
{
graph.RemoveCommentBlock(commentBlock.commentBlock);
RemoveElement(commentBlock);
return(true);
}
return(false);
});
}
return(changes);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
m_serializedBehaviorTreeObject.Update();
Undo.SetCurrentGroupName("Behavior Tree changed");
int undoGroup = Undo.GetCurrentGroup();
Undo.RegisterCompleteObjectUndo(m_serializedBehaviorTree, "Changed Behavior Tree");
if (graphViewChange.elementsToRemove != null)
{
RemoveElements(graphViewChange.elementsToRemove);
}
if (graphViewChange.edgesToCreate != null)
{
CreateEdges(graphViewChange.edgesToCreate);
}
if (graphViewChange.movedElements != null)
{
MoveElements(graphViewChange.movedElements, graphViewChange.moveDelta);
}
m_serializedBehaviorTreeObject.ApplyModifiedProperties();
Undo.CollapseUndoOperations(undoGroup);
return(graphViewChange);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
graphViewChange.elementsToRemove?.ForEach(elem =>
{
if (elem is NodeView nodeView)
{
tree.DeleteNode(nodeView.node);
}
if (!(elem is Edge edge))
{
return;
}
NodeView parentNode = edge.output.node as NodeView;
NodeView childNode = edge.input.node as NodeView;
tree.RemoveChild(parentNode.node, childNode.node);
});
graphViewChange.edgesToCreate?.ForEach(edge =>
{
NodeView parentNode = edge.output.node as NodeView;
NodeView childNode = edge.input.node as NodeView;
tree.AddChild(parentNode.node, childNode.node);
});
return(graphViewChange);
}
GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
{
//Debug.Log("graph move elements: " + graphViewChange.movedElements);
//Debug.Log("graph edges to create: " + graphViewChange.edgesToCreate);
//Debug.Log("graph move delta: " + graphViewChange.moveDelta);
return(graphViewChange);
}
GraphViewChange GraphViewChangedCallback(GraphViewChange changes)
{
if (changes.elementsToRemove != null)
{
RegisterCompleteObjectUndo("Remove Graph Elements");
// Destroy priority of objects
// We need nodes to be destroyed first because we can have a destroy operation that uses node connections
changes.elementsToRemove.Sort((e1, e2) => {
int GetPriority(GraphElement e)
{
if (e is BaseNodeView)
{
return(0);
}
else
{
return(1);
}
}
return(GetPriority(e1).CompareTo(GetPriority(e2)));
});
//Handle ourselves the edge and node remove
changes.elementsToRemove.RemoveAll(e => {
switch (e)
{
case EdgeView edge:
Disconnect(edge);
return(true);
case BaseNodeView nodeView:
ExceptionToLog.Call(() => nodeView.OnRemoved());
graph.RemoveNode(nodeView.nodeTarget);
RemoveElement(nodeView);
return(true);
case GroupView group:
graph.RemoveGroup(group.group);
RemoveElement(group);
return(true);
case ExposedParameterFieldView blackboardField:
graph.RemoveExposedParameter(blackboardField.parameter);
return(true);
case BaseStackNodeView stackNodeView:
graph.RemoveStackNode(stackNodeView.stackNode);
RemoveElement(stackNodeView);
return(true);
}
return(false);
});
}
return(changes);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
OnMovedElements(graphViewChange.movedElements);
OnRemovedElements(graphViewChange.elementsToRemove);
OnCreatedEdges(graphViewChange.edgesToCreate);
return(graphViewChange);
}
private GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
{
bool needToComputeOutputs = false;
if (graphViewChange.elementsToRemove != null)
{
foreach (GraphElement element in graphViewChange.elementsToRemove)
{
if (element is Placemat || element is Node || element is Group || element is BlackboardField || element is StickyNote)
{
ElementDeletedCallback(element);
if (element is BlackboardField)
{
m_GraphView.RebuildBlackboard();
}
}
else if (element is Edge)
{
EdgeDisconnected(element as Edge);
}
}
m_GraphView.window.RemoveEmptyScopes();
needToComputeOutputs = true;
}
if (graphViewChange.edgesToCreate != null)
{
foreach (Edge edge in graphViewChange.edgesToCreate)
{
EdgeConnected(edge);
}
needToComputeOutputs = true;
}
if (graphViewChange.movedElements != null)
{
foreach (GraphElement element in graphViewChange.movedElements)
{
MathNode mathNode = element.userData as MathNode;
if (mathNode == null)
{
continue;
}
mathNode.m_Position = element.layout.position;
}
}
if (needToComputeOutputs)
{
m_MathBook.inputOutputs.ComputeOutputs();
}
return(graphViewChange);
}
GraphViewChange OnChange(GraphViewChange change)
{
if (change.edgesToCreate != null)
{
foreach (var edge in change.edgesToCreate)
{
cachedEdges.Add(edge);
}
}
return(change);
}
GraphViewChange OnGraphViewChange(GraphViewChange graphViewChange)
{
if (graphViewChange.elementsToRemove != null)
{
foreach (Placemat placemat in graphViewChange.elementsToRemove.OfType <Placemat>())
{
RemovePlacemat(placemat);
}
}
return(graphViewChange);
}
private GraphViewChange OnGraphViewChange(GraphViewChange change)
{
if (change.edgesToCreate != null)
{
for (int i = 0; i < change.edgesToCreate.Count; i++)
{
var edge = change.edgesToCreate[i];
var fromNode = edge.output.node as BaseNode;
var toNode = edge.input.node as BaseNode;
edge.RegisterCallback <MouseUpEvent>(OnMouseUp, TrickleDown.TrickleDown);
_graphData.SetLink(fromNode.GUID, edge.output.portName, toNode.GUID);
}
}
if (change.elementsToRemove != null)
{
for (int i = 0; i < change.elementsToRemove.Count; i++)
{
var element = change.elementsToRemove[i];
if (element is BaseNode)
{
var node = change.elementsToRemove[i] as BaseNode;
_graphData.RemoveNode(node.GUID);
RemoveState(node.GUID);
}
else if (element is Edge)
{
var edge = change.elementsToRemove[i] as Edge;
edge.UnregisterCallback <MouseUpEvent>(OnMouseUp, TrickleDown.TrickleDown);
_graphData.RemoveLink((edge.output.node as BaseNode).GUID, edge.output.portName);
}
}
}
if (change.movedElements != null)
{
for (int i = 0; i < change.movedElements.Count; i++)
{
if (change.movedElements[i] is BaseNode)
{
var node = change.movedElements[i] as BaseNode;
_graphData.SetNodePosition(node.GUID, node.GetPosition().position);
}
}
}
return(change);
}
private GraphViewChange Changes(GraphViewChange graphViewChange)
{
if (graphViewChange.movedElements != null)
{
foreach (var moved in graphViewChange.movedElements)
{
if (moved is DrawNodeViewGraph drawNode)
{
drawNode.InnerNode.coords = drawNode.GetPosition().position;
}
}
}
if (graphViewChange.edgesToCreate != null)
{
foreach (var e in graphViewChange.edgesToCreate)
{
var input = NeededNode(e.input, Direction.Input);
var output = NeededNode(e.output, Direction.Output);
((FieldInfo)output.ConnectedPorts[e.output].member).SetValue(output.InnerNode, input.InnerNode);
}
}
if (graphViewChange.elementsToRemove != null)
{
foreach (var remove in graphViewChange.elementsToRemove)
{
if (remove is Edge edge)
{
foreach (var dn in drawNodes)
{
foreach (var portInfo in dn.ConnectedPorts.ToArray())
{
if (portInfo.Key == edge.output && portInfo.Value.direction == Direction.Output)
{
((FieldInfo)portInfo.Value.member)?.SetValue(dn.InnerNode, null);
}
}
}
}
if (remove is DrawNodeViewGraph node)
{
strategy.nodes.AddOrRemoveElement(node.InnerNode, false);
ClearNodes();
}
}
}
return(graphViewChange);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
editorWindow.InvalidateSaveButton();
if (graphViewChange.movedElements?.Count > 0)
{
Debug.Log(graphViewChange.movedElements[0].GetPosition().position);
}
if (graphViewChange.elementsToRemove?.Count > 0)
{
foreach (var node in graphViewChange.elementsToRemove.OfType <AbstractNode>())
{
if (node.GroupGuid == Guid.Empty || !GroupGuidDictionary.ContainsKey(node.GroupGuid))
{
continue;
}
var group = GroupGuidDictionary[node.GroupGuid].GroupReference;
if (group.containedElements.Count() == 1)
{
RemoveGroup(group);
}
}
}
if (graphViewChange.edgesToCreate?.Count > 0)
{
graphViewChange.edgesToCreate.ForEach(edge => {
var input = edge.input.node as AbstractNode;
var output = edge.output.node as AbstractNode;
EventExtenderNode extenderNode = null;
AbstractNode other = null;
if (input is EventExtenderNode && edge.input.direction != Direction.Output)
{
extenderNode = input as EventExtenderNode;
other = output;
}
else if (output is EventExtenderNode && edge.output.direction != Direction.Output)
{
extenderNode = output as EventExtenderNode;
other = input;
}
extenderNode?.UpdateSourceTitle(other.title);
});
}
return(graphViewChange);
}
private GraphViewChange OnGraphChanged(GraphViewChange graphViewChange)
{
if (graphViewChange.elementsToRemove != null)
{
var nodes = graphViewChange.elementsToRemove.OfType <GraphViewNode>();
var edges = graphViewChange.elementsToRemove.OfType <Edge>();
foreach (var node in nodes)
{
RemoveNode(node, nodes);
}
foreach (var edge in edges)
{
RemoveEdge(edge, true);
}
graphViewChange.elementsToRemove.Clear();
}
if (graphViewChange.edgesToCreate != null)
{
foreach (var edge in graphViewChange.edgesToCreate)
{
AddEdge(edge);
}
graphViewChange.edgesToCreate.Clear();
}
if (graphViewChange.movedElements != null)
{
foreach (var element in graphViewChange.movedElements)
{
if (element is GraphViewNode node && node.IsMovable())
{
SetNodePosition(node.Data.Node, node.Data.Node.GraphPosition + graphViewChange.moveDelta);
}
}
graphViewChange.movedElements.Clear();
}
return(graphViewChange);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange change)
{
// Dirty moved elements to update the target assets
if (change.movedElements != null)
{
foreach (var element in change.movedElements)
{
if (element is ICanDirty)
{
Dirty(element as ICanDirty);
}
// TODO: Move/optimize
if (element is NodeView)
{
UpdateCommentLink(element as NodeView);
}
}
}
if (change.elementsToRemove != null)
{
foreach (var element in change.elementsToRemove)
{
if (element is NodeView)
{
DestroyNode(element as NodeView);
}
else if (element is Edge)
{
DestroyEdge(element as Edge);
}
else if (element is CommentView)
{
DestroyComment(element as CommentView);
}
}
// Save the batch of changes all at once
AssetDatabase.SaveAssets();
}
return(change);
}
private GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
{
Debug.Log($"GraphViewChanged {graphViewChange}");
if (graphViewChange.edgesToCreate != null)
{
Debug.Log("EDGES TO CREATE " + graphViewChange.edgesToCreate.Count);
}
if (graphViewChange.movedElements != null)
{
Debug.Log("Moved elements " + graphViewChange.movedElements.Count);
_logicGraphEditorObject.RegisterCompleteObjectUndo("Graph Element Moved.");
foreach (var element in graphViewChange.movedElements)
{
AbstractLogicNodeEditor logicNodeEditor = element.userData as AbstractLogicNodeEditor;
logicNodeEditor.Position = element.GetPosition().position;
logicNodeEditor.SerializedNode.JSON = JsonUtility.ToJson(logicNodeEditor);
}
}
if (graphViewChange.elementsToRemove != null)
{
Debug.Log("Elements to remove" + graphViewChange.elementsToRemove.Count);
_logicGraphEditorObject.RegisterCompleteObjectUndo("Deleted Graph Elements.");
foreach (var nodeView in graphViewChange.elementsToRemove.OfType <LogicNodeView>())
{
_logicGraphEditorObject.LogicGraphData.SerializedNodes.Remove(nodeView.LogicNodeEditor.SerializedNode);
_logicGraphEditorObject.LogicGraphData.SerializedInputNodes.Remove(nodeView.LogicNodeEditor
.SerializedNode);
_logicGraphEditorObject.LogicGraphData.SerializedOutputNodes.Remove(nodeView.LogicNodeEditor
.SerializedNode);
}
foreach (var edge in graphViewChange.elementsToRemove.OfType <Edge>())
{
_logicGraphEditorObject.LogicGraphData.SerializedEdges.Remove(edge.userData as SerializedEdge);
}
}
return(graphViewChange);
}
GraphViewChange OnGraphViewChanged(GraphViewChange change)
{
if (change.movedElements != null)
{
foreach (var element in change.movedElements)
{
// TODO: Move/optimize
if (element is NodeView node)
{
UpdateCommentLink(node);
}
}
// Moved nodes will update their underlying models automatically.
EditorUtility.SetDirty(m_Graph);
}
if (change.elementsToRemove != null)
{
foreach (var element in change.elementsToRemove)
{
if (element is NodeView node)
{
RemoveNode(node);
}
else if (element is Edge edge)
{
RemoveEdge(edge, true);
}
else if (element is CommentView comment)
{
RemoveComment(comment);
}
if (element is ICanDirty canDirty)
{
m_Dirty.Remove(canDirty);
}
}
}
return(change);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange change)
{
if (change.movedElements != null)
{
foreach (var element in change.movedElements)
{
// TODO: Move/optimize
if (element is NodeView node)
{
UpdateCommentLink(node);
}
}
}
if (change.elementsToRemove != null)
{
foreach (var element in change.elementsToRemove)
{
if (element is NodeView node)
{
DestroyNode(node);
}
else if (element is Edge edge)
{
DestroyEdge(edge);
}
else if (element is CommentView comment)
{
DestroyComment(comment);
}
if (element is ICanDirty canDirty)
{
m_Dirty.Remove(canDirty);
}
}
// Save the batch of changes all at once
AssetDatabase.SaveAssets();
}
return(change);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
if (graphViewChange.elementsToRemove != null)
{
foreach (var elem in graphViewChange.elementsToRemove)
{
if (elem is BaseNodeView nodeView)
{
_graph.RemoveNode(nodeView.Node);
}
if (elem is BaseConnectionView connectionView)
{
_graph.Disconnect(connectionView.Connection);
}
}
}
return(graphViewChange);
}
GraphViewChange GraphViewChangedCallback(GraphViewChange changes)
{
if (changes.elementsToRemove != null)
{
RegisterCompleteObjectUndo("Remove Graph Elements");
//Handle ourselves the edge and node remove
changes.elementsToRemove.RemoveAll(e => {
switch (e)
{
case EdgeView edge:
Disconnect(edge);
return(true);
case BaseNodeView node:
ExceptionToLog.Call(() => node.OnRemoved());
graph.RemoveNode(node.nodeTarget);
RemoveElement(node);
UpdateNodeInspectorSelection();
return(true);
case GroupView group:
graph.RemoveGroup(group.group);
RemoveElement(group);
return(true);
case ExposedParameterFieldView blackboardField:
graph.RemoveExposedParameter(blackboardField.parameter);
return(true);
case BaseStackNodeView stackNodeView:
graph.RemoveStackNode(stackNodeView.stackNode);
RemoveElement(stackNodeView);
return(true);
}
return(false);
});
}
return(changes);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange changes)
{
if (changes.elementsToRemove == null)
{
return(changes);
}
changes.elementsToRemove.Sort((e1, e2) => {
int GetPriority(GraphElement e)
{
return(e is TaskNode ? 0 : 1);
}
return(GetPriority(e1).CompareTo(GetPriority(e2)));
});
changes.elementsToRemove.RemoveAll(e =>
{
switch (e)
{
case Edge edge:
Disconnect(edge);
return(true);
case TaskNode node:
foreach (var edge in node.Input?.connections?.ToList() ?? Enumerable.Empty <Edge>())
{
Disconnect(edge);
}
foreach (var edge in node.Output?.connections?.ToList() ?? Enumerable.Empty <Edge>())
{
Disconnect(edge);
}
return(false);
case BlackboardField field:
Properties.RemoveAll(x => x.Name == field.text);
return(false);
}
return(false);
});
return(changes);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
var toRemove = graphViewChange;
if (graphViewChange.elementsToRemove != null)
{
foreach (GraphElement remove in graphViewChange.elementsToRemove)
{
BTNodeView nodeView = remove as BTNodeView;
if (nodeView != null)
{
if (nodeView.SerializedNode == _btAsset.Root)
{
toRemove.elementsToRemove.Remove(remove);
break;
}
_btAsset.RemoveNode(nodeView.SerializedNode);
}
Edge edge = remove as Edge;
if (edge != null)
{
BTNodeView parent = edge.output.node as BTNodeView;
BTNodeView child = edge.input.node as BTNodeView;
parent.SerializedNode.RemoveChild(child.SerializedNode);
}
}
}
if (graphViewChange.edgesToCreate != null)
{
foreach (Edge edge in graphViewChange.edgesToCreate)
{
BTNodeView parent = edge.output.node as BTNodeView;
BTNodeView child = edge.input.node as BTNodeView;
parent.SerializedNode.AddChild(child.SerializedNode);
}
}
return(toRemove);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange change)
{
if (serializedGraph == null)
{
return(change);
}
if (change.movedElements != null)
{
// Moved nodes will update their underlying models automatically.
EditorUtility.SetDirty(Graph);
}
if (change.elementsToRemove != null)
{
foreach (var element in change.elementsToRemove)
{
if (element is NodeView node)
{
RemoveNode(node);
}
else if (element is GraphViewEdge edge)
{
RemoveEdge(edge, true);
}
else if (element is CommentView comment)
{
RemoveComment(comment);
}
if (element is ICanDirty canDirty)
{
dirtyElements.Remove(canDirty);
}
}
}
return(change);
}
public GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
{
if (graphViewChange.edgesToCreate != null)
{
Debug.Log("EDGES TO CREATE " + graphViewChange.edgesToCreate.Count);
}
if (graphViewChange.movedElements != null)
{
// _logicGraphEditorObject.RegisterCompleteObjectUndo("Graph Element Moved.");
foreach (var element in graphViewChange.movedElements)
{
GraphNode nodeEditor = element as GraphNode;
nodeEditor.Position = element.GetPosition().position;
//nodeEditor.SerializedNode.JSON = JsonUtility.ToJson(nodeEditor);
}
}
if (graphViewChange.elementsToRemove != null)
{
//_logicGraphEditorObject.RegisterCompleteObjectUndo("Deleted Graph Elements.");
/*foreach (var nodeView in graphViewChange.elementsToRemove.OfType<LogicNodeView>())
* {
* _logicGraphEditorObject.LogicGraphData.SerializedNodes.Remove(nodeView.NodeEditor.SerializedNode);
* _logicGraphEditorObject.LogicGraphData.SerializedInputNodes.Remove(nodeView.NodeEditor.SerializedNode);
* _logicGraphEditorObject.LogicGraphData.SerializedOutputNodes.Remove(nodeView.NodeEditor.SerializedNode);
* }*/
/*foreach (var edge in graphViewChange.elementsToRemove.OfType<Edge>())
* {
* _logicGraphEditorObject.LogicGraphData.SerializedEdges.Remove(edge.userData as SerializedEdge);
* }*/
}
return(graphViewChange);
}
private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
if (graphViewChange.elementsToRemove != null)
{
int group = Undo.GetCurrentGroup();
Undo.RegisterCompleteObjectUndo(NodeGraph, "Deleted Graph Elements");
List <NodeView> nodeViewsToDelete = new List <NodeView>();
for (int i = graphViewChange.elementsToRemove.Count - 1; i >= 0; i--)
{
if (graphViewChange.elementsToRemove[i] is NodeView)
{
nodeViewsToDelete.Add(graphViewChange.elementsToRemove[i] as NodeView);
}
else if (graphViewChange.elementsToRemove[i] is EdgeView)
{
EdgeView edgeView = graphViewChange.elementsToRemove[i] as EdgeView;
edgeView.FirstPort.Node.RemoveEdge(edgeView);
}
}
DeleteNodes(nodeViewsToDelete);
Undo.CollapseUndoOperations(group);
}
else if (graphViewChange.movedElements != null)
{
int group = Undo.GetCurrentGroup();
Undo.RegisterCompleteObjectUndo(NodeGraph, "Moved Graph Elements");
for (int k = 0; k < graphViewChange.movedElements.Count; k++)
{
if (graphViewChange.movedElements[k] is NodeView)
{
(graphViewChange.movedElements[k] as NodeView).UpdateNodeDataPosition();
}
}
Undo.CollapseUndoOperations(group);
}
return(graphViewChange);
}
public void OnDrop(GraphView graphView, Edge edge)
{
var edgesToDelete = new List <GraphElement>();
if (edge.input.capacity == Port.Capacity.Single)
{
edgesToDelete.AddRange(edge.input.connections.Where(e => e != edge));
}
if (edge.output.capacity == Port.Capacity.Single)
{
edgesToDelete.AddRange(edge.output.connections.Where(e => e != edge));
}
if (edgesToDelete.Count > 0)
{
graphView.DeleteElements(edgesToDelete);
}
var edgesToCreate = new List <Edge>()
{
edge
};
if (graphView.graphViewChanged != null)
{
var graphViewChange = new GraphViewChange();
graphViewChange.edgesToCreate = edgesToCreate;
edgesToCreate = graphView.graphViewChanged(graphViewChange).edgesToCreate;
}
foreach (var e in edgesToCreate)
{
graphView.AddElement(e);
edge.input.Connect(e);
edge.output.Connect(e);
}
}
GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
{
if (graphViewChange.edgesToCreate != null)
{
foreach (var edge in graphViewChange.edgesToCreate)
{
var leftSlot = edge.output.GetSlot();
var rightSlot = edge.input.GetSlot();
if (leftSlot != null && rightSlot != null)
{
m_Graph.owner.RegisterCompleteObjectUndo("Connect Edge");
m_Graph.Connect(leftSlot.slotReference, rightSlot.slotReference);
}
}
graphViewChange.edgesToCreate.Clear();
}
if (graphViewChange.movedElements != null)
{
foreach (var element in graphViewChange.movedElements)
{
var node = element.userData as INode;
if (node == null)
{
continue;
}
var drawState = node.drawState;
drawState.position = element.GetPosition();
node.drawState = drawState;
}
}
var nodesToUpdate = m_NodeViewHashSet;
nodesToUpdate.Clear();
if (graphViewChange.elementsToRemove != null)
{
m_Graph.owner.RegisterCompleteObjectUndo("Remove Elements");
m_Graph.RemoveElements(graphViewChange.elementsToRemove.OfType <MaterialNodeView>().Select(v => (INode)v.node),
graphViewChange.elementsToRemove.OfType <Edge>().Select(e => (IEdge)e.userData));
foreach (var edge in graphViewChange.elementsToRemove.OfType <Edge>())
{
if (edge.input != null)
{
var materialNodeView = edge.input.node as MaterialNodeView;
if (materialNodeView != null)
{
nodesToUpdate.Add(materialNodeView);
}
}
if (edge.output != null)
{
var materialNodeView = edge.output.node as MaterialNodeView;
if (materialNodeView != null)
{
nodesToUpdate.Add(materialNodeView);
}
}
}
}
foreach (var node in nodesToUpdate)
{
node.UpdatePortInputVisibilities();
}
UpdateEdgeColors(nodesToUpdate);
return(graphViewChange);
}
