mirror of
https://github.com/Siccity/xNode.git
synced 2025-12-20 17:26:02 +08:00
c58648d663
Can now adjust color of group node resize icon. Changed header label rendering to always be vertically centered. Changed group node style. Changed rename text field style.
952 lines
40 KiB
C#
952 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 Vector2 lastMouseDownPosition;
|
|
private readonly float dragThreshold = 5f;
|
|
|
|
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 (IsHoveringNode && IsHoveringTitle(hoveredNode) &&
|
|
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 (isPanning || (lastMouseDownPosition - e.mousePosition).sqrMagnitude >
|
|
dragThreshold * dragThreshold)
|
|
{
|
|
isPanning = true;
|
|
panOffset += e.delta * zoom;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case EventType.MouseDown:
|
|
Repaint();
|
|
lastMouseDownPosition = e.mousePosition;
|
|
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 (IsHoveringNode && IsHoveringTitle(hoveredNode) &&
|
|
(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)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
public 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, NodeEditor.GetEditor(node, current)
|
|
.GetHeaderStyle().fixedHeight / 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;
|
|
}
|
|
}
|
|
} |