mirror of
https://github.com/Siccity/xNode.git
synced 2025-12-20 01:06:01 +08:00
945 lines
40 KiB
C#
945 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using XNode;
|
|
using XNodeEditor.Internal;
|
|
using Object = UnityEngine.Object;
|
|
#if UNITY_2019_1_OR_NEWER && USE_ADVANCED_GENERIC_MENU
|
|
using GenericMenu = XNodeEditor.AdvancedGenericMenu;
|
|
#endif
|
|
|
|
namespace XNodeEditor
|
|
{
|
|
public partial class NodeEditorWindow
|
|
{
|
|
public enum NodeActivity
|
|
{
|
|
Idle,
|
|
HoldNode,
|
|
DragNode,
|
|
HoldGrid,
|
|
DragGrid,
|
|
Renaming
|
|
}
|
|
public static NodeActivity currentActivity = NodeActivity.Idle;
|
|
public static bool isPanning { get; private set; }
|
|
public static Vector2[] dragOffset;
|
|
|
|
public static Node[] copyBuffer;
|
|
|
|
public bool IsDraggingPort => draggedOutput != null;
|
|
public bool IsHoveringPort => hoveredPort != null;
|
|
public bool IsHoveringNode => hoveredNode != null;
|
|
public bool IsHoveringReroute => hoveredReroute.port != null;
|
|
public bool IsSelectingRenamingObject =>
|
|
currentActivity == NodeActivity.Renaming && IsHoveringNode && Selection.Contains(hoveredNode);
|
|
|
|
/// <summary> Return the dragged port or null if not exist </summary>
|
|
public NodePort DraggedOutputPort
|
|
{
|
|
get
|
|
{
|
|
NodePort result = draggedOutput;
|
|
return result;
|
|
}
|
|
}
|
|
/// <summary> Return the Hovered port or null if not exist </summary>
|
|
public NodePort HoveredPort
|
|
{
|
|
get
|
|
{
|
|
NodePort result = hoveredPort;
|
|
return result;
|
|
}
|
|
}
|
|
/// <summary> Return the Hovered node or null if not exist </summary>
|
|
public Node HoveredNode
|
|
{
|
|
get
|
|
{
|
|
Node result = hoveredNode;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
private Node hoveredNode;
|
|
[NonSerialized] public NodePort hoveredPort = null;
|
|
[NonSerialized] private NodePort draggedOutput;
|
|
[NonSerialized] private NodePort draggedOutputTarget;
|
|
[NonSerialized] private NodePort autoConnectOutput;
|
|
[NonSerialized] private List<Vector2> draggedOutputReroutes = new List<Vector2>();
|
|
|
|
private RerouteReference hoveredReroute;
|
|
public List<RerouteReference> selectedReroutes = new List<RerouteReference>();
|
|
private Vector2 dragBoxStart;
|
|
private Object[] preBoxSelection;
|
|
private RerouteReference[] preBoxSelectionReroute;
|
|
private Rect selectionBox;
|
|
private bool isDoubleClick;
|
|
private Vector2 lastMousePosition;
|
|
private float dragThreshold = 1f;
|
|
|
|
public void Controls()
|
|
{
|
|
wantsMouseMove = true;
|
|
Event e = Event.current;
|
|
switch (e.type)
|
|
{
|
|
case EventType.DragUpdated:
|
|
case EventType.DragPerform:
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
|
|
if (e.type == EventType.DragPerform)
|
|
{
|
|
DragAndDrop.AcceptDrag();
|
|
graphEditor.OnDropObjects(DragAndDrop.objectReferences);
|
|
}
|
|
|
|
break;
|
|
case EventType.MouseMove:
|
|
//Keyboard commands will not get correct mouse position from Event
|
|
lastMousePosition = e.mousePosition;
|
|
break;
|
|
case EventType.ScrollWheel:
|
|
float oldZoom = zoom;
|
|
if (e.delta.y > 0)
|
|
{
|
|
zoom += 0.1f * zoom;
|
|
}
|
|
else
|
|
{
|
|
zoom -= 0.1f * zoom;
|
|
}
|
|
|
|
if (NodeEditorPreferences.GetSettings().zoomToMouse)
|
|
{
|
|
panOffset += (1 - oldZoom / zoom) * (WindowToGridPosition(e.mousePosition) + panOffset);
|
|
}
|
|
|
|
break;
|
|
case EventType.MouseDrag:
|
|
if (e.button == 0)
|
|
{
|
|
if (IsDraggingPort)
|
|
{
|
|
// Set target even if we can't connect, so as to prevent auto-conn menu from opening erroneously
|
|
if (IsHoveringPort && hoveredPort.IsInput && !draggedOutput.IsConnectedTo(hoveredPort))
|
|
{
|
|
draggedOutputTarget = hoveredPort;
|
|
}
|
|
else
|
|
{
|
|
draggedOutputTarget = null;
|
|
}
|
|
|
|
Repaint();
|
|
}
|
|
else if (currentActivity == NodeActivity.HoldNode)
|
|
{
|
|
RecalculateDragOffsets(e);
|
|
isDoubleClick = false;
|
|
currentActivity = NodeActivity.DragNode;
|
|
Repaint();
|
|
}
|
|
|
|
if (currentActivity == NodeActivity.DragNode)
|
|
{
|
|
// Holding ctrl inverts grid snap
|
|
bool gridSnap = NodeEditorPreferences.GetSettings().gridSnap;
|
|
if (e.control)
|
|
{
|
|
gridSnap = !gridSnap;
|
|
}
|
|
|
|
Vector2 mousePos = WindowToGridPosition(e.mousePosition);
|
|
// Move selected nodes with offset
|
|
for (int i = 0; i < Selection.objects.Length; i++)
|
|
{
|
|
if (Selection.objects[i] is Node)
|
|
{
|
|
Node node = Selection.objects[i] as Node;
|
|
Undo.RecordObject(node, "Moved Node");
|
|
Vector2 initial = node.position;
|
|
node.position = mousePos + dragOffset[i];
|
|
if (gridSnap)
|
|
{
|
|
node.position.x = Mathf.Round((node.position.x + 8) / 16) * 16 - 8;
|
|
node.position.y = Mathf.Round((node.position.y + 8) / 16) * 16 - 8;
|
|
}
|
|
|
|
// Offset portConnectionPoints instantly if a node is dragged so they aren't delayed by a frame.
|
|
Vector2 offset = node.position - initial;
|
|
if (offset.sqrMagnitude > 0)
|
|
{
|
|
foreach (NodePort output in node.Outputs)
|
|
{
|
|
Rect rect;
|
|
if (portConnectionPoints.TryGetValue(output, out rect))
|
|
{
|
|
rect.position += offset;
|
|
portConnectionPoints[output] = rect;
|
|
}
|
|
}
|
|
|
|
foreach (NodePort input in node.Inputs)
|
|
{
|
|
Rect rect;
|
|
if (portConnectionPoints.TryGetValue(input, out rect))
|
|
{
|
|
rect.position += offset;
|
|
portConnectionPoints[input] = rect;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Move selected reroutes with offset
|
|
for (int i = 0; i < selectedReroutes.Count; i++)
|
|
{
|
|
Vector2 pos = mousePos + dragOffset[Selection.objects.Length + i];
|
|
if (gridSnap)
|
|
{
|
|
pos.x = Mathf.Round(pos.x / 16) * 16;
|
|
pos.y = Mathf.Round(pos.y / 16) * 16;
|
|
}
|
|
|
|
selectedReroutes[i].SetPoint(pos);
|
|
}
|
|
|
|
Repaint();
|
|
}
|
|
else if (currentActivity == NodeActivity.HoldGrid)
|
|
{
|
|
currentActivity = NodeActivity.DragGrid;
|
|
preBoxSelection = Selection.objects;
|
|
preBoxSelectionReroute = selectedReroutes.ToArray();
|
|
dragBoxStart = WindowToGridPosition(e.mousePosition);
|
|
Repaint();
|
|
}
|
|
else if (currentActivity == NodeActivity.DragGrid)
|
|
{
|
|
Vector2 boxStartPos = GridToWindowPosition(dragBoxStart);
|
|
Vector2 boxSize = e.mousePosition - boxStartPos;
|
|
if (boxSize.x < 0)
|
|
{
|
|
boxStartPos.x += boxSize.x;
|
|
boxSize.x = Mathf.Abs(boxSize.x);
|
|
}
|
|
|
|
if (boxSize.y < 0)
|
|
{
|
|
boxStartPos.y += boxSize.y;
|
|
boxSize.y = Mathf.Abs(boxSize.y);
|
|
}
|
|
|
|
selectionBox = new Rect(boxStartPos, boxSize);
|
|
Repaint();
|
|
}
|
|
}
|
|
else if (e.button == 1 || e.button == 2)
|
|
{
|
|
//check drag threshold for larger screens
|
|
if (e.delta.magnitude > dragThreshold)
|
|
{
|
|
panOffset += e.delta * zoom;
|
|
isPanning = true;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case EventType.MouseDown:
|
|
Repaint();
|
|
if (e.button == 0)
|
|
{
|
|
draggedOutputReroutes.Clear();
|
|
|
|
if (IsHoveringPort)
|
|
{
|
|
if (hoveredPort.IsOutput)
|
|
{
|
|
draggedOutput = hoveredPort;
|
|
autoConnectOutput = hoveredPort;
|
|
}
|
|
else
|
|
{
|
|
hoveredPort.VerifyConnections();
|
|
autoConnectOutput = null;
|
|
if (hoveredPort.IsConnected)
|
|
{
|
|
Node node = hoveredPort.node;
|
|
NodePort output = hoveredPort.Connection;
|
|
int outputConnectionIndex = output.GetConnectionIndex(hoveredPort);
|
|
draggedOutputReroutes = output.GetReroutePoints(outputConnectionIndex);
|
|
hoveredPort.Disconnect(output);
|
|
draggedOutput = output;
|
|
draggedOutputTarget = hoveredPort;
|
|
if (NodeEditor.onUpdateNode != null)
|
|
{
|
|
NodeEditor.onUpdateNode(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentActivity == NodeActivity.Renaming)
|
|
{
|
|
currentActivity = NodeActivity.Idle;
|
|
}
|
|
}
|
|
else if (IsHoveringNode && IsHoveringTitle(hoveredNode) &&
|
|
(currentActivity != NodeActivity.Renaming || !IsSelectingRenamingObject))
|
|
{
|
|
// If mousedown on node header, select or deselect
|
|
if (!Selection.Contains(hoveredNode))
|
|
{
|
|
SelectNode(hoveredNode, e.control || e.shift);
|
|
if (!e.control && !e.shift)
|
|
{
|
|
selectedReroutes.Clear();
|
|
}
|
|
}
|
|
else if (e.control || e.shift)
|
|
{
|
|
DeselectNode(hoveredNode);
|
|
}
|
|
|
|
// Cache double click state, but only act on it in MouseUp - Except ClickCount only works in mouseDown.
|
|
isDoubleClick = e.clickCount == 2;
|
|
|
|
e.Use();
|
|
currentActivity = NodeActivity.HoldNode;
|
|
}
|
|
else if (IsHoveringReroute)
|
|
{
|
|
// If reroute isn't selected
|
|
if (!selectedReroutes.Contains(hoveredReroute))
|
|
{
|
|
// Add it
|
|
if (e.control || e.shift)
|
|
{
|
|
selectedReroutes.Add(hoveredReroute);
|
|
}
|
|
// Select it
|
|
else
|
|
{
|
|
selectedReroutes = new List<RerouteReference> { hoveredReroute };
|
|
Selection.activeObject = null;
|
|
}
|
|
}
|
|
// Deselect
|
|
else if (e.control || e.shift)
|
|
{
|
|
selectedReroutes.Remove(hoveredReroute);
|
|
}
|
|
|
|
e.Use();
|
|
currentActivity = NodeActivity.HoldNode;
|
|
}
|
|
// If mousedown on grid background, deselect all
|
|
else if (!IsHoveringNode)
|
|
{
|
|
currentActivity = NodeActivity.HoldGrid;
|
|
if (!e.control && !e.shift)
|
|
{
|
|
selectedReroutes.Clear();
|
|
Selection.activeObject = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case EventType.MouseUp:
|
|
if (e.button == 0)
|
|
{
|
|
//Port drag release
|
|
if (IsDraggingPort)
|
|
{
|
|
// If connection is valid, save it
|
|
if (draggedOutputTarget != null &&
|
|
graphEditor.CanConnect(draggedOutput, draggedOutputTarget))
|
|
{
|
|
Node node = draggedOutputTarget.node;
|
|
if (graph.nodes.Count != 0)
|
|
{
|
|
draggedOutput.Connect(draggedOutputTarget);
|
|
}
|
|
|
|
// ConnectionIndex can be -1 if the connection is removed instantly after creation
|
|
int connectionIndex = draggedOutput.GetConnectionIndex(draggedOutputTarget);
|
|
if (connectionIndex != -1)
|
|
{
|
|
draggedOutput.GetReroutePoints(connectionIndex).AddRange(draggedOutputReroutes);
|
|
if (NodeEditor.onUpdateNode != null)
|
|
{
|
|
NodeEditor.onUpdateNode(node);
|
|
}
|
|
|
|
EditorUtility.SetDirty(graph);
|
|
}
|
|
}
|
|
// Open context menu for auto-connection if there is no target node
|
|
else if (draggedOutputTarget == null && NodeEditorPreferences.GetSettings().dragToCreate &&
|
|
autoConnectOutput != null)
|
|
{
|
|
GenericMenu menu = new GenericMenu();
|
|
graphEditor.AddContextMenuItems(menu, draggedOutput.ValueType);
|
|
menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
|
|
}
|
|
|
|
//Release dragged connection
|
|
draggedOutput = null;
|
|
draggedOutputTarget = null;
|
|
EditorUtility.SetDirty(graph);
|
|
if (NodeEditorPreferences.GetSettings().autoSave)
|
|
{
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
else if (currentActivity == NodeActivity.DragNode)
|
|
{
|
|
var nodes = Selection.objects.Where(x => x is Node).Select(x => x as Node);
|
|
foreach (Node node in nodes)
|
|
{
|
|
EditorUtility.SetDirty(node);
|
|
}
|
|
|
|
if (NodeEditorPreferences.GetSettings().autoSave)
|
|
{
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
else if (!IsHoveringNode)
|
|
{
|
|
// If click outside node, release field focus
|
|
if (!isPanning)
|
|
{
|
|
EditorGUI.FocusTextInControl(null);
|
|
EditorGUIUtility.editingTextField = false;
|
|
}
|
|
|
|
if (NodeEditorPreferences.GetSettings().autoSave)
|
|
{
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
|
|
// If click node header, select it.
|
|
if ((currentActivity == NodeActivity.HoldNode || !IsSelectingRenamingObject) &&
|
|
!(e.control || e.shift))
|
|
{
|
|
selectedReroutes.Clear();
|
|
// SelectNode(hoveredNode, false);
|
|
|
|
// Double click to rename node
|
|
if (isDoubleClick)
|
|
{
|
|
RenameSelectedNodeTextField();
|
|
// Vector2 nodeDimension = nodeSizes.ContainsKey(hoveredNode)
|
|
// ? nodeSizes[hoveredNode] / 2
|
|
// : Vector2.zero;
|
|
// panOffset = -hoveredNode.position - nodeDimension;
|
|
}
|
|
else
|
|
{
|
|
currentActivity = NodeActivity.HoldNode;
|
|
}
|
|
}
|
|
else if (currentActivity != NodeActivity.Renaming)
|
|
{
|
|
currentActivity = NodeActivity.Idle;
|
|
}
|
|
|
|
// If click reroute, select it.
|
|
if (IsHoveringReroute && !(e.control || e.shift))
|
|
{
|
|
selectedReroutes = new List<RerouteReference> { hoveredReroute };
|
|
Selection.activeObject = null;
|
|
}
|
|
|
|
Repaint();
|
|
}
|
|
else if (e.button == 1 || e.button == 2)
|
|
{
|
|
if (!isPanning)
|
|
{
|
|
if (IsDraggingPort)
|
|
{
|
|
draggedOutputReroutes.Add(WindowToGridPosition(e.mousePosition));
|
|
}
|
|
else if (currentActivity == NodeActivity.DragNode && Selection.activeObject == null &&
|
|
selectedReroutes.Count == 1)
|
|
{
|
|
selectedReroutes[0].InsertPoint(selectedReroutes[0].GetPoint());
|
|
selectedReroutes[0] = new RerouteReference(selectedReroutes[0].port,
|
|
selectedReroutes[0].connectionIndex, selectedReroutes[0].pointIndex + 1);
|
|
}
|
|
else if (IsHoveringReroute)
|
|
{
|
|
ShowRerouteContextMenu(hoveredReroute);
|
|
}
|
|
else if (IsHoveringPort)
|
|
{
|
|
ShowPortContextMenu(hoveredPort);
|
|
}
|
|
else if (IsHoveringNode && IsHoveringTitle(hoveredNode))
|
|
{
|
|
if (!Selection.Contains(hoveredNode))
|
|
{
|
|
SelectNode(hoveredNode, false);
|
|
}
|
|
|
|
autoConnectOutput = null;
|
|
GenericMenu menu = new GenericMenu();
|
|
NodeEditor.GetEditor(hoveredNode, this).AddContextMenuItems(menu);
|
|
menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
|
|
e.Use(); // Fixes copy/paste context menu appearing in Unity 5.6.6f2 - doesn't occur in 2018.3.2f1 Probably needs to be used in other places.
|
|
}
|
|
else if (!IsHoveringNode)
|
|
{
|
|
autoConnectOutput = null;
|
|
GenericMenu menu = new GenericMenu();
|
|
graphEditor.AddContextMenuItems(menu);
|
|
menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
|
|
}
|
|
|
|
if (currentActivity == NodeActivity.Renaming)
|
|
{
|
|
currentActivity = NodeActivity.Idle;
|
|
}
|
|
}
|
|
|
|
isPanning = false;
|
|
}
|
|
|
|
// Reset DoubleClick
|
|
isDoubleClick = false;
|
|
break;
|
|
case EventType.KeyDown:
|
|
if (EditorGUIUtility.editingTextField)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (e.keyCode == KeyCode.F)
|
|
{
|
|
Home();
|
|
}
|
|
|
|
if (NodeEditorUtilities.IsMac())
|
|
{
|
|
if (e.keyCode == KeyCode.Return)
|
|
{
|
|
RenameSelectedNodeTextField();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (e.keyCode == KeyCode.F2)
|
|
{
|
|
RenameSelectedNodeTextField();
|
|
}
|
|
}
|
|
|
|
if (e.keyCode == KeyCode.A)
|
|
{
|
|
if (Selection.objects.Any(x => graph.nodes.Contains(x as Node)))
|
|
{
|
|
foreach (Node node in graph.nodes)
|
|
{
|
|
DeselectNode(node);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (Node node in graph.nodes)
|
|
{
|
|
SelectNode(node, true);
|
|
}
|
|
}
|
|
|
|
Repaint();
|
|
}
|
|
|
|
break;
|
|
case EventType.ValidateCommand:
|
|
case EventType.ExecuteCommand:
|
|
if (e.commandName == "SoftDelete")
|
|
{
|
|
if (e.type == EventType.ExecuteCommand)
|
|
{
|
|
RemoveSelectedNodes();
|
|
}
|
|
|
|
e.Use();
|
|
}
|
|
else if (NodeEditorUtilities.IsMac() && e.commandName == "Delete")
|
|
{
|
|
if (e.type == EventType.ExecuteCommand)
|
|
{
|
|
RemoveSelectedNodes();
|
|
}
|
|
|
|
e.Use();
|
|
}
|
|
else if (e.commandName == "Duplicate")
|
|
{
|
|
if (e.type == EventType.ExecuteCommand)
|
|
{
|
|
DuplicateSelectedNodes();
|
|
}
|
|
|
|
e.Use();
|
|
}
|
|
else if (e.commandName == "Copy")
|
|
{
|
|
if (!EditorGUIUtility.editingTextField)
|
|
{
|
|
if (e.type == EventType.ExecuteCommand)
|
|
{
|
|
CopySelectedNodes();
|
|
}
|
|
|
|
e.Use();
|
|
}
|
|
}
|
|
else if (e.commandName == "Paste")
|
|
{
|
|
if (!EditorGUIUtility.editingTextField)
|
|
{
|
|
if (e.type == EventType.ExecuteCommand)
|
|
{
|
|
PasteNodes(WindowToGridPosition(lastMousePosition));
|
|
}
|
|
|
|
e.Use();
|
|
}
|
|
}
|
|
|
|
Repaint();
|
|
break;
|
|
case EventType.Ignore:
|
|
// If release mouse outside window
|
|
if (e.rawType == EventType.MouseUp && currentActivity == NodeActivity.DragGrid)
|
|
{
|
|
Repaint();
|
|
currentActivity = NodeActivity.Idle;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (currentActivity != NodeActivity.Renaming && RenameTextField.IsActive)
|
|
{
|
|
RenameTextField.current.SaveAndClose();
|
|
}
|
|
}
|
|
|
|
private void RecalculateDragOffsets(Event current)
|
|
{
|
|
dragOffset = new Vector2[Selection.objects.Length + selectedReroutes.Count];
|
|
// Selected nodes
|
|
for (int i = 0; i < Selection.objects.Length; i++)
|
|
{
|
|
if (Selection.objects[i] is Node)
|
|
{
|
|
Node node = Selection.objects[i] as Node;
|
|
dragOffset[i] = node.position - WindowToGridPosition(current.mousePosition);
|
|
}
|
|
}
|
|
|
|
// Selected reroutes
|
|
for (int i = 0; i < selectedReroutes.Count; i++)
|
|
{
|
|
dragOffset[Selection.objects.Length + i] =
|
|
selectedReroutes[i].GetPoint() - WindowToGridPosition(current.mousePosition);
|
|
}
|
|
}
|
|
|
|
/// <summary> Puts all selected nodes in focus. If no nodes are present, resets view and zoom to to origin </summary>
|
|
public void Home()
|
|
{
|
|
var nodes = Selection.objects.Where(o => o is Node).Cast<Node>().ToList();
|
|
if (nodes.Count > 0)
|
|
{
|
|
Vector2 minPos = nodes.Select(x => x.position)
|
|
.Aggregate((x, y) => new Vector2(Mathf.Min(x.x, y.x), Mathf.Min(x.y, y.y)));
|
|
Vector2 maxPos = nodes
|
|
.Select(x => x.position + (nodeSizes.ContainsKey(x) ? nodeSizes[x] : Vector2.zero))
|
|
.Aggregate((x, y) => new Vector2(Mathf.Max(x.x, y.x), Mathf.Max(x.y, y.y)));
|
|
panOffset = -(minPos + (maxPos - minPos) / 2f);
|
|
}
|
|
else
|
|
{
|
|
zoom = 2;
|
|
panOffset = Vector2.zero;
|
|
}
|
|
}
|
|
|
|
/// <summary> Remove nodes in the graph in Selection.objects</summary>
|
|
public void RemoveSelectedNodes()
|
|
{
|
|
// We need to delete reroutes starting at the highest point index to avoid shifting indices
|
|
selectedReroutes = selectedReroutes.OrderByDescending(x => x.pointIndex).ToList();
|
|
for (int i = 0; i < selectedReroutes.Count; i++)
|
|
{
|
|
selectedReroutes[i].RemovePoint();
|
|
}
|
|
|
|
selectedReroutes.Clear();
|
|
foreach (Object item in Selection.objects)
|
|
{
|
|
if (item is Node)
|
|
{
|
|
Node node = item as Node;
|
|
graphEditor.RemoveNode(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary> Initiate a rename on the currently selected node </summary>
|
|
public void RenameSelectedNode()
|
|
{
|
|
if (Selection.objects.Length == 1 && Selection.activeObject is Node)
|
|
{
|
|
Node node = Selection.activeObject as Node;
|
|
Vector2 size;
|
|
if (nodeSizes.TryGetValue(node, out size))
|
|
{
|
|
RenamePopup.Show(Selection.activeObject, size.x);
|
|
}
|
|
else
|
|
{
|
|
RenamePopup.Show(Selection.activeObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void RenameSelectedNodeTextField()
|
|
{
|
|
if (Selection.activeObject is Node)
|
|
{
|
|
currentActivity = NodeActivity.Renaming;
|
|
RenameTextField.Show(Selection.activeObject);
|
|
}
|
|
}
|
|
|
|
/// <summary> Draw this node on top of other nodes by placing it last in the graph.nodes list </summary>
|
|
public void MoveNodeToTop(Node node)
|
|
{
|
|
int index;
|
|
while ((index = graph.nodes.IndexOf(node)) != graph.nodes.Count - 1)
|
|
{
|
|
graph.nodes[index] = graph.nodes[index + 1];
|
|
graph.nodes[index + 1] = node;
|
|
}
|
|
}
|
|
|
|
/// <summary> Duplicate selected nodes and select the duplicates </summary>
|
|
public void DuplicateSelectedNodes()
|
|
{
|
|
// Get selected nodes which are part of this graph
|
|
var selectedNodes = Selection.objects.Select(x => x as Node).Where(x => x != null && x.graph == graph)
|
|
.ToArray();
|
|
if (selectedNodes == null || selectedNodes.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get top left node position
|
|
Vector2 topLeftNode = selectedNodes.Select(x => x.position)
|
|
.Aggregate((x, y) => new Vector2(Mathf.Min(x.x, y.x), Mathf.Min(x.y, y.y)));
|
|
InsertDuplicateNodes(selectedNodes, topLeftNode + new Vector2(30, 30));
|
|
}
|
|
|
|
public void CopySelectedNodes()
|
|
{
|
|
copyBuffer = Selection.objects.Select(x => x as Node).Where(x => x != null && x.graph == graph).ToArray();
|
|
}
|
|
|
|
public void PasteNodes(Vector2 pos)
|
|
{
|
|
InsertDuplicateNodes(copyBuffer, pos);
|
|
}
|
|
|
|
private void InsertDuplicateNodes(Node[] nodes, Vector2 topLeft)
|
|
{
|
|
if (nodes == null || nodes.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get top-left node
|
|
Vector2 topLeftNode = nodes.Select(x => x.position)
|
|
.Aggregate((x, y) => new Vector2(Mathf.Min(x.x, y.x), Mathf.Min(x.y, y.y)));
|
|
Vector2 offset = topLeft - topLeftNode;
|
|
|
|
var newNodes = new Object[nodes.Length];
|
|
var substitutes = new Dictionary<Node, Node>();
|
|
for (int i = 0; i < nodes.Length; i++)
|
|
{
|
|
Node srcNode = nodes[i];
|
|
if (srcNode == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Check if user is allowed to add more of given node type
|
|
Node.DisallowMultipleNodesAttribute disallowAttrib;
|
|
Type nodeType = srcNode.GetType();
|
|
if (NodeEditorUtilities.GetAttrib(nodeType, out disallowAttrib))
|
|
{
|
|
int typeCount = graph.nodes.Count(x => x.GetType() == nodeType);
|
|
if (typeCount >= disallowAttrib.max)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
Node newNode = graphEditor.CopyNode(srcNode);
|
|
substitutes.Add(srcNode, newNode);
|
|
newNode.position = srcNode.position + offset;
|
|
newNodes[i] = newNode;
|
|
}
|
|
|
|
// Walk through the selected nodes again, recreate connections, using the new nodes
|
|
for (int i = 0; i < nodes.Length; i++)
|
|
{
|
|
Node srcNode = nodes[i];
|
|
if (srcNode == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
foreach (NodePort port in srcNode.Ports)
|
|
{
|
|
for (int c = 0; c < port.ConnectionCount; c++)
|
|
{
|
|
NodePort inputPort = port.direction == NodePort.IO.Input ? port : port.GetConnection(c);
|
|
NodePort outputPort = port.direction == NodePort.IO.Output ? port : port.GetConnection(c);
|
|
|
|
Node newNodeIn, newNodeOut;
|
|
if (substitutes.TryGetValue(inputPort.node, out newNodeIn) &&
|
|
substitutes.TryGetValue(outputPort.node, out newNodeOut))
|
|
{
|
|
newNodeIn.UpdatePorts();
|
|
newNodeOut.UpdatePorts();
|
|
inputPort = newNodeIn.GetInputPort(inputPort.fieldName);
|
|
outputPort = newNodeOut.GetOutputPort(outputPort.fieldName);
|
|
}
|
|
|
|
if (!inputPort.IsConnectedTo(outputPort))
|
|
{
|
|
inputPort.Connect(outputPort);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
EditorUtility.SetDirty(graph);
|
|
// Select the new nodes
|
|
Selection.objects = newNodes;
|
|
}
|
|
|
|
/// <summary> Draw a connection as we are dragging it </summary>
|
|
public void DrawDraggedConnection()
|
|
{
|
|
if (IsDraggingPort)
|
|
{
|
|
Gradient gradient = graphEditor.GetNoodleGradient(draggedOutput, null);
|
|
float thickness = graphEditor.GetNoodleThickness(draggedOutput, null);
|
|
NoodlePath path = graphEditor.GetNoodlePath(draggedOutput, null);
|
|
NoodleStroke stroke = graphEditor.GetNoodleStroke(draggedOutput, null);
|
|
|
|
Rect fromRect;
|
|
if (!portConnectionPoints.TryGetValue(draggedOutput, out fromRect))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var gridPoints = new List<Vector2>();
|
|
gridPoints.Add(fromRect.center);
|
|
for (int i = 0; i < draggedOutputReroutes.Count; i++)
|
|
{
|
|
gridPoints.Add(draggedOutputReroutes[i]);
|
|
}
|
|
|
|
if (draggedOutputTarget != null)
|
|
{
|
|
gridPoints.Add(portConnectionPoints[draggedOutputTarget].center);
|
|
}
|
|
else
|
|
{
|
|
gridPoints.Add(WindowToGridPosition(Event.current.mousePosition));
|
|
}
|
|
|
|
DrawNoodle(gradient, path, stroke, thickness, gridPoints);
|
|
|
|
GUIStyle portStyle = current.graphEditor.GetPortStyle(draggedOutput);
|
|
Color bgcol = Color.black;
|
|
Color frcol = gradient.colorKeys[0].color;
|
|
bgcol.a = 0.6f;
|
|
frcol.a = 0.6f;
|
|
|
|
// Loop through reroute points again and draw the points
|
|
for (int i = 0; i < draggedOutputReroutes.Count; i++)
|
|
{
|
|
// Draw reroute point at position
|
|
Rect rect = new Rect(draggedOutputReroutes[i], new Vector2(16, 16));
|
|
rect.position = new Vector2(rect.position.x - 8, rect.position.y - 8);
|
|
rect = GridToWindowRect(rect);
|
|
|
|
NodeEditorGUILayout.DrawPortHandle(rect, bgcol, frcol, portStyle.normal.background,
|
|
portStyle.active.background);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsHoveringTitle(Node node)
|
|
{
|
|
Vector2 mousePos = Event.current.mousePosition;
|
|
//Get node position
|
|
Vector2 nodePos = GridToWindowPosition(node.position);
|
|
float width;
|
|
Vector2 size;
|
|
if (nodeSizes.TryGetValue(node, out size))
|
|
{
|
|
width = size.x;
|
|
}
|
|
else
|
|
{
|
|
width = 200;
|
|
}
|
|
|
|
Rect windowRect = new Rect(nodePos, new Vector2(width / zoom, 30 / zoom));
|
|
return windowRect.Contains(mousePos);
|
|
}
|
|
|
|
/// <summary> Attempt to connect dragged output to target node </summary>
|
|
public void AutoConnect(Node node)
|
|
{
|
|
if (autoConnectOutput == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Find compatible input port
|
|
NodePort inputPort =
|
|
node.Ports.FirstOrDefault(x => x.IsInput && graphEditor.CanConnect(autoConnectOutput, x));
|
|
if (inputPort != null)
|
|
{
|
|
autoConnectOutput.Connect(inputPort);
|
|
}
|
|
|
|
// Save changes
|
|
EditorUtility.SetDirty(graph);
|
|
if (NodeEditorPreferences.GetSettings().autoSave)
|
|
{
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
|
|
autoConnectOutput = null;
|
|
}
|
|
}
|
|
} |