/// <summary>
/// Remove an edge from both the canvas view and the underlying graph model
/// </summary>
public void RemoveEdge(GraphViewEdge edge, bool registerAsNewUndo)
{
var input = edge.input as PortView;
var output = edge.output as PortView;
if (registerAsNewUndo)
{
Undo.RegisterCompleteObjectUndo(Graph, "Remove Edge");
}
// Disconnect the ports in the model
Graph.RemoveEdge(input.Target, output.Target);
serializedGraph.Update();
EditorUtility.SetDirty(Graph);
// Remove the edge view
edge.input.Disconnect(edge);
edge.output.Disconnect(edge);
edge.input = null;
edge.output = null;
RemoveElement(edge);
// Dirty the affected node views
Dirty(input.node as NodeView);
Dirty(output.node as NodeView);
}
public void OnDropOutsidePort(UnityEditor.Experimental.GraphView.Edge edge, Vector2 position)
{
var draggedPort = edge.output?.edgeConnector.edgeDragHelper.draggedPort ?? edge.input?.edgeConnector.edgeDragHelper.draggedPort;
m_SearchWindowProvider.connectedPort = (NodePort)draggedPort;
SearchWindow.Open(new SearchWindowContext(GUIUtility.GUIToScreenPoint(Event.current.mousePosition)), m_SearchWindowProvider);
}
public void OnDropOutsidePort(Edge edge, Vector2 position)
{
var draggedPort = (edge.output != null ? edge.output.edgeConnector.edgeDragHelper.draggedPort : null) ?? (edge.input != null ? edge.input.edgeConnector.edgeDragHelper.draggedPort : null);
m_SearchWindowProvider.connectedPort = (ShaderPort)draggedPort;
SearchWindow.Open(new SearchWindowContext(GUIUtility.GUIToScreenPoint(Event.current.mousePosition)), m_SearchWindowProvider);
}
/// <summary>
/// Remove an edge from both the canvas view and the underlying graph model
/// </summary>
public void RemoveEdge(Edge edge, bool registerAsNewUndo)
{
var input = edge.input as PortView;
var output = edge.output as PortView;
if (registerAsNewUndo)
{
Undo.RegisterCompleteObjectUndo(m_Graph, "Remove Edge");
}
Debug.Log($"-edge {input.portName} to {output.portName}");
// Disconnect the ports in the model
m_Graph.RemoveEdge(input.target, output.target);
m_SerializedGraph.Update();
EditorUtility.SetDirty(m_Graph);
// Remove the edge view
edge.input.Disconnect(edge);
edge.output.Disconnect(edge);
edge.input = null;
edge.output = null;
RemoveElement(edge);
// Dirty the affected node views
Dirty(input.node as NodeView);
Dirty(output.node as NodeView);
}
/// <summary>
/// Add a new edge to both the canvas view and the underlying graph model
/// </summary>
public void AddEdge(GraphViewEdge edge, bool registerAsNewUndo)
{
try
{
if (edge.input == null || edge.output == null)
{
return;
}
if (registerAsNewUndo)
{
Undo.RegisterCompleteObjectUndo(Graph, "Add Edge");
}
// Handle single connection ports on either end.
var edgesToRemove = new List <GraphViewEdge>();
if (edge.input.capacity == GraphViewPort.Capacity.Single)
{
foreach (var conn in edge.input.connections)
{
edgesToRemove.Add(conn);
}
}
if (edge.output.capacity == GraphViewPort.Capacity.Single)
{
foreach (var conn in edge.output.connections)
{
edgesToRemove.Add(conn);
}
}
foreach (var edgeToRemove in edgesToRemove)
{
RemoveEdge(edgeToRemove, false);
}
var input = edge.input as PortView;
var output = edge.output as PortView;
// Connect the ports in the model
Graph.AddEdge(input.Target, output.Target);
serializedGraph.Update();
EditorUtility.SetDirty(Graph);
// Add a matching edge view onto the canvas
var newEdge = input.ConnectTo(output);
AddElement(newEdge);
// Dirty the affected node views
Dirty(input.node as NodeView);
Dirty(output.node as NodeView);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
public void OnDropOutsidePort(Edge edge, Vector2 position)
{
var draggedPort = (edge.output != null ? edge.output.edgeConnector.edgeDragHelper.draggedPort : null) ?? (edge.input != null ? edge.input.edgeConnector.edgeDragHelper.draggedPort : null);
m_SearchWindowProvider.connectedPort = (ShaderPort)draggedPort;
SearcherWindow.Show(m_editorWindow, (m_SearchWindowProvider as SearcherProvider).LoadSearchWindow(),
item => (m_SearchWindowProvider as SearcherProvider).OnSearcherSelectEntry(item, position),
position, null);
}
public void OnDrop(GraphView graphView, UnityEditor.Experimental.GraphView.Edge edge)
{
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);
}
}
public void BuildEdge(EditorView editorView)
{
EditorView = editorView;
var inputNode = editorView.GraphView.nodes.ToList().Find(node => node.viewDataKey == Input) as AbstractNode;
var outputNode = editorView.GraphView.nodes.ToList().Find(node => node.viewDataKey == Output) as AbstractNode;
var inputPort = inputNode.Owner.GuidPortDictionary[InputPort];
var outputPort = outputNode.Owner.GuidPortDictionary[OutputPort];
Edge = inputPort.ConnectTo(outputPort);
Edge.userData = this;
}
public void OnDropOutsidePort(Edge edge, Vector2 position)
{
var draggedPort = (edge.output != null ? edge.output.edgeConnector.edgeDragHelper.draggedPort : null) ?? (edge.input != null ? edge.input.edgeConnector.edgeDragHelper.draggedPort : null);
m_SearchWindowProvider.connectedPort = (ShaderPort)draggedPort;
m_SearchWindowProvider.regenerateEntries = true;//need to be sure the entires are relevant to the edge we are dragging
SearcherWindow.Show(m_editorWindow, (m_SearchWindowProvider as SearcherProvider).LoadSearchWindow(),
item => (m_SearchWindowProvider as SearcherProvider).OnSearcherSelectEntry(item, position),
position, null);
m_SearchWindowProvider.regenerateEntries = true;//entries no longer necessarily relevant, need to regenerate
}
/// <summary>
/// Create a new node from reflection data and insert into the Graph.
/// </summary>
internal void AddNodeFromSearch(Node node, Vector2 screenPosition, PortView connectedPort = null, bool registerUndo = true)
{
// Calculate where to place this node on the graph
var windowRoot = EditorWindow.rootVisualElement;
var windowMousePosition = EditorWindow.rootVisualElement.ChangeCoordinatesTo(
windowRoot.parent,
screenPosition - EditorWindow.position.position
);
var graphMousePosition = contentViewContainer.WorldToLocal(windowMousePosition);
// Track undo and add to the graph
if (registerUndo)
{
Undo.RegisterCompleteObjectUndo(Graph, $"Add Node {node.Name}");
}
node.Position = graphMousePosition;
Graph.AddNode(node);
serializedGraph.Update();
EditorUtility.SetDirty(Graph);
// Add a node to the visual graph
var editorType = NodeReflection.GetNodeEditorType(node.GetType());
var element = Activator.CreateInstance(editorType) as NodeView;
element.Initialize(node, this, edgeConnectorListener);
AddElement(element);
// If there was a provided existing port to connect to, find the best
// candidate port on the new node and connect.
if (connectedPort != null)
{
var edge = new GraphViewEdge();
if (connectedPort.direction == Direction.Input)
{
edge.input = connectedPort;
edge.output = element.GetCompatibleOutputPort(connectedPort);
}
else
{
edge.output = connectedPort;
edge.input = element.GetCompatibleInputPort(connectedPort);
}
AddEdge(edge, false);
}
Dirty(element);
}
GEdge AddEdge(IEdge edge)
{
var sourceNode = m_Graph.GetNodeFromGuid(edge.outputSlot.nodeGuid);
if (sourceNode == null)
{
Debug.LogWarning("Source node is null");
return(null);
}
var sourceSlot = sourceNode.FindOutputSlot <NodeSlot>(edge.outputSlot.slotId);
var targetNode = m_Graph.GetNodeFromGuid(edge.inputSlot.nodeGuid);
if (targetNode == null)
{
Debug.LogWarning("Target node is null");
return(null);
}
var targetSlot = targetNode.FindInputSlot <NodeSlot>(edge.inputSlot.slotId);
var sourceNodeView = m_GraphView.nodes.ToList().OfType <NodeView>().FirstOrDefault(x => x.node == sourceNode);
if (sourceNodeView != null)
{
var sourceAnchor = sourceNodeView.outputContainer.Children().OfType <NodePort>().FirstOrDefault(x => x.slot.Equals(sourceSlot));
var targetNodeView = m_GraphView.nodes.ToList().OfType <NodeView>().FirstOrDefault(x => x.node == targetNode);
var targetAnchor = targetNodeView.inputContainer.Children().OfType <NodePort>().FirstOrDefault(x => x.slot.Equals(targetSlot));
var edgeView = new GEdge
{
userData = edge,
output = sourceAnchor,
input = targetAnchor
};
edgeView.output.Connect(edgeView);
edgeView.input.Connect(edgeView);
m_GraphView.AddElement(edgeView);
sourceNodeView.RefreshPorts();
targetNodeView.RefreshPorts();
sourceNodeView.UpdatePortInputTypes();
targetNodeView.UpdatePortInputTypes();
return(edgeView);
}
return(null);
}
/// <summary>
/// Generates a connection (edge) between graph nodes
/// </summary>
public void GenerateEdge()
{
var tempEdge = new GraphView.Edge()
{
output = ParentPort,
input = InputPort,
};
tempEdge?.input.Connect(tempEdge);
tempEdge?.output.Connect(tempEdge);
Add(tempEdge);
RefreshExpandedState();
RefreshPorts();
}
/// <summary>
/// Activate the search dialog when an edge is dropped on an arbitrary location
/// </summary>
public void OnDropOutsidePort(GraphViewEdge edge, Vector2 position)
{
var screenPosition = GUIUtility.GUIToScreenPoint(
Event.current.mousePosition
);
if (edge.output != null)
{
canvas.OpenSearch(
screenPosition,
edge.output.edgeConnector.edgeDragHelper.draggedPort as PortView
);
}
else if (edge.input != null)
{
canvas.OpenSearch(
screenPosition,
edge.input.edgeConnector.edgeDragHelper.draggedPort as PortView
);
}
}
public void OnDropOutsidePort(Edge edge, Vector2 position)
{
}
/// <summary>
/// Handle connecting nodes when an edge is dropped between two ports
/// </summary>
public void OnDrop(GraphView graphView, GraphViewEdge edge)
{
canvas.AddEdge(edge, true);
}
/// <summary>
/// Create a new node from reflection data and insert into the Graph.
/// </summary>
internal void AddNodeFromReflectionData(
NodeReflectionData data,
Vector2 screenPosition,
PortView connectedPort = null
)
{
// Calculate where to place this node on the graph
var windowRoot = m_EditorWindow.rootVisualElement;
var windowMousePosition = m_EditorWindow.rootVisualElement.ChangeCoordinatesTo(
windowRoot.parent,
screenPosition - m_EditorWindow.position.position
);
var graphMousePosition = contentViewContainer.WorldToLocal(windowMousePosition);
// Create a new node instance and set initial data (ports, etc)
Undo.RegisterCompleteObjectUndo(m_Graph, $"Add Node {data.name}");
Debug.Log($"+node {data.name}");
var node = data.CreateInstance();
node.graphPosition = graphMousePosition;
m_Graph.AddNode(node);
m_SerializedGraph.Update();
EditorUtility.SetDirty(m_Graph);
var serializedNodesArr = m_SerializedGraph.FindProperty("nodes");
var nodeIdx = m_Graph.nodes.IndexOf(node);
var serializedNode = serializedNodesArr.GetArrayElementAtIndex(nodeIdx);
// Add a node to the visual graph
var editorType = NodeReflection.GetNodeEditorType(data.type);
var element = Activator.CreateInstance(editorType) as NodeView;
element.Initialize(node, serializedNode, m_EdgeListener);
AddElement(element);
// If there was a provided existing port to connect to, find the best
// candidate port on the new node and connect.
if (connectedPort != null)
{
var edge = new Edge();
if (connectedPort.direction == Direction.Input)
{
edge.input = connectedPort;
edge.output = element.GetCompatibleOutputPort(connectedPort);
}
else
{
edge.output = connectedPort;
edge.input = element.GetCompatibleInputPort(connectedPort);
}
AddEdge(edge, false);
}
Dirty(element);
}
/// <summary>
/// Add a new edge to both the canvas view and the underlying graph model
/// </summary>
public void AddEdge(Edge edge, bool registerAsNewUndo)
{
if (edge.input == null || edge.output == null)
{
return;
}
if (edge.input.node != null && edge.input.node is NodeView in_view)
{
in_view.UpdateBinding();
}
if (edge.output.node != null && edge.output.node is NodeView out_view)
{
out_view.UpdateBinding();
}
if (registerAsNewUndo)
{
Undo.RegisterCompleteObjectUndo(m_Graph, "Add Edge");
}
// Handle single connection ports on either end.
var edgesToRemove = new List <Edge>();
if (edge.input.capacity == Port.Capacity.Single)
{
foreach (var conn in edge.input.connections)
{
edgesToRemove.Add(conn);
}
}
if (edge.output.capacity == Port.Capacity.Single)
{
foreach (var conn in edge.output.connections)
{
edgesToRemove.Add(conn);
}
}
foreach (var edgeToRemove in edgesToRemove)
{
RemoveEdge(edgeToRemove, false);
}
var input = edge.input as PortView;
var output = edge.output as PortView;
Debug.Log($"+edge {input.portName} to {output.portName}");
// Connect the ports in the model
m_Graph.AddEdge(input.target, output.target);
m_SerializedGraph.Update();
EditorUtility.SetDirty(m_Graph);
// Add a matching edge view onto the canvas
var newEdge = input.ConnectTo(output);
AddElement(newEdge);
// Dirty the affected node views
Dirty(input.node as NodeView);
Dirty(output.node as NodeView);
}
