1179 lines
48 KiB
C#
1179 lines
48 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Reflection;
|
||
using Ichni.RhythmGame;
|
||
using TMPro;
|
||
using UniRx;
|
||
using UnityEngine;
|
||
using UnityEngine.EventSystems;
|
||
using UnityEngine.InputSystem;
|
||
using UnityEngine.UI;
|
||
using UnityEngine.UI.Extensions;
|
||
|
||
namespace Ichni.NodeScript
|
||
{
|
||
public class NodeManager : MonoBehaviour
|
||
{
|
||
public static NodeManager Instance;
|
||
|
||
public List<NodeObject> allNodes = new();
|
||
public GameObject nodeObjectPrefab;
|
||
Canvas canvas;
|
||
UILineRenderer dragLine;
|
||
public float wireThickness = 5f;
|
||
|
||
ConnectorSlot dragSource;
|
||
bool isDraggingWire;
|
||
|
||
// 中键拖拽面板
|
||
Vector2 _panelDragOrigin;
|
||
bool _isPanning;
|
||
|
||
// 单步调试
|
||
bool _debugMode;
|
||
int _debugStep;
|
||
|
||
public class WireConnection { public ConnectorSlot from, to; public UILineRenderer line; public bool selected; }
|
||
public List<WireConnection> connections = new();
|
||
|
||
public RectTransform canvasArea;
|
||
public Camera refCamera;
|
||
public Transform contextMenuRoot;
|
||
public Transform NodeArea;
|
||
public GameObject contextMenuItemPrefab;
|
||
public GameObject uiInputPrefab;
|
||
|
||
public GameElement startElement { get; private set; }
|
||
|
||
// ---- 命名变量存储 ----
|
||
Dictionary<string, object> _variables = new();
|
||
|
||
// ---- 脏元素收集，图执行完后统一 Refresh ----
|
||
HashSet<GameElement> _dirtyElements = new();
|
||
public void MarkDirty(GameElement e) { if (e != null) _dirtyElements.Add(e); }
|
||
|
||
// ---- 生命周期调度表 ----
|
||
HashSet<NodeBase> triggerTable = new();
|
||
HashSet<NodeBase> runtimeTable = new();
|
||
|
||
public T GetVariable<T>(string name)
|
||
{
|
||
if (_variables.TryGetValue(name, out var v) && v is T tv) return tv;
|
||
return default;
|
||
}
|
||
|
||
public void SetVariable<T>(string name, T value) { _variables[name] = value; }
|
||
|
||
public bool TryGetVariable<T>(string name, out T v)
|
||
{
|
||
if (_variables.TryGetValue(name, out var obj) && obj is T tv) { v = tv; return true; }
|
||
v = default; return false;
|
||
}
|
||
|
||
void Awake()
|
||
{
|
||
if (Instance != null && Instance != this) { Destroy(this); return; }
|
||
Instance = this;
|
||
canvas = GetComponentInParent<Canvas>();
|
||
}
|
||
void OnDestroy()
|
||
{
|
||
if (Instance == this) Instance = null;
|
||
foreach (var w in connections) { if (w.line != null && w.line.gameObject != null) Destroy(w.line.gameObject); }
|
||
connections.Clear();
|
||
if (dragLine != null && dragLine.gameObject != null) Destroy(dragLine.gameObject);
|
||
}
|
||
|
||
void Start()
|
||
{
|
||
if (refCamera == null) refCamera = canvas != null ? canvas.worldCamera : Camera.main;
|
||
dragLine = CreateWire("DragWire", Color.white);
|
||
|
||
dragLine.raycastTarget = false;
|
||
dragLine.gameObject.SetActive(false);
|
||
if (contextMenuRoot != null) contextMenuRoot.gameObject.SetActive(false);
|
||
}
|
||
|
||
/// <summary>外部实例化 Manager 后调用，传入入口 GameElement 并自动创建 Start 节点</summary>
|
||
public void Init(GameElement element)
|
||
{
|
||
startElement = element;
|
||
allNodes = FindObjectsByType<NodeObject>(FindObjectsSortMode.None).ToList();
|
||
|
||
if (!allNodes.Any(n => n.nodeBase is NodeStart))
|
||
{
|
||
var data = new NodeStart { NodeName = "Start", boundElement = element };
|
||
data.InitConnectors();
|
||
var go = nodeObjectPrefab != null ? Instantiate(nodeObjectPrefab, NodeArea) : new GameObject("Start", typeof(RectTransform));
|
||
var no = go.GetComponent<NodeObject>(); if (no == null) no = go.AddComponent<NodeObject>();
|
||
no.nodeBase = data;
|
||
go.GetComponent<RectTransform>().anchoredPosition = new Vector2(-400, 0);
|
||
no.Init(); allNodes.Add(no);
|
||
}
|
||
}
|
||
|
||
List<NodeObject> selectedNodes = new();
|
||
(List<(Type type, Dictionary<string, object> fields)> nodes,
|
||
List<(int fromIdx, int toIdx, string outName, string inName)> wires) clipboard = (new(), new());
|
||
|
||
void Update()
|
||
{
|
||
if (Keyboard.current == null) return;
|
||
|
||
var mousePos = Mouse.current.position.ReadValue();
|
||
|
||
// ---- 手动线悬停 / 点击检测 ----
|
||
WireConnection clickedWire = UpdateWireHover();
|
||
|
||
// ---- 空位点击 → 取消所有选中（线点击已在上一步处理） ----
|
||
if (Mouse.current.leftButton.wasPressedThisFrame && clickedWire == null)
|
||
{
|
||
var ped = new PointerEventData(EventSystem.current) { position = mousePos };
|
||
var hits = new List<RaycastResult>(); EventSystem.current.RaycastAll(ped, hits);
|
||
bool hitUI = hits.Any(r =>
|
||
r.gameObject.GetComponent<NodeObject>() != null ||
|
||
r.gameObject.GetComponent<ConnectorSlot>() != null);
|
||
if (!hitUI) DeselectAll();
|
||
}
|
||
|
||
// ---- 中键拖拽整个节点面板 ----
|
||
if (Mouse.current.middleButton.wasPressedThisFrame)
|
||
{
|
||
_panelDragOrigin = mousePos;
|
||
_isPanning = true;
|
||
}
|
||
if (_isPanning && Mouse.current.middleButton.isPressed)
|
||
{
|
||
var delta = mousePos - _panelDragOrigin;
|
||
_panelDragOrigin = mousePos;
|
||
var nodeAreaRt = NodeArea as RectTransform;
|
||
if (nodeAreaRt != null)
|
||
nodeAreaRt.anchoredPosition += delta / (canvas != null ? canvas.scaleFactor : 1f);
|
||
RefreshAllLines();
|
||
}
|
||
if (Mouse.current.middleButton.wasReleasedThisFrame)
|
||
_isPanning = false;
|
||
|
||
// Esc → 退出调试
|
||
if (Keyboard.current.escapeKey.wasPressedThisFrame && _debugMode)
|
||
DebugReset();
|
||
|
||
// Shift+Enter → 单步
|
||
if (Keyboard.current.leftShiftKey.isPressed && Keyboard.current.enterKey.wasPressedThisFrame)
|
||
{
|
||
if (!_debugMode) DebugInit();
|
||
DebugStep();
|
||
}
|
||
// Ctrl+Enter → Run（保留）
|
||
if (Keyboard.current.leftCtrlKey.isPressed && Keyboard.current.enterKey.wasPressedThisFrame)
|
||
RunGraph();
|
||
|
||
// Ctrl+RightClick → Create Node
|
||
if (Keyboard.current.leftCtrlKey.isPressed && Mouse.current.rightButton.wasPressedThisFrame)
|
||
TryShowContextMenu(Mouse.current.position.ReadValue());
|
||
|
||
// Delete → Remove selected
|
||
if (Keyboard.current.deleteKey.wasPressedThisFrame)
|
||
DeleteSelected();
|
||
|
||
// Ctrl+C → Copy
|
||
if (Keyboard.current.leftCtrlKey.isPressed && Keyboard.current.cKey.wasPressedThisFrame)
|
||
CopySelected();
|
||
|
||
// Ctrl+V → Paste
|
||
if (Keyboard.current.leftCtrlKey.isPressed && Keyboard.current.vKey.wasPressedThisFrame)
|
||
PasteClipboard();
|
||
|
||
// F5 → 拓扑预览
|
||
if (Keyboard.current.f5Key.wasPressedThisFrame)
|
||
PreviewOrder();
|
||
|
||
// // F1 → Save
|
||
// if (Keyboard.current.f1Key.wasPressedThisFrame)
|
||
// SaveToFile();
|
||
|
||
// // F2 → Load
|
||
// if (Keyboard.current.f2Key.wasPressedThisFrame)
|
||
// LoadFromFile();
|
||
}
|
||
|
||
// ========== 选中 ==========
|
||
void DeselectAll()
|
||
{
|
||
foreach (var n in selectedNodes) n.Selected = false;
|
||
selectedNodes.Clear();
|
||
foreach (var w in connections) w.selected = false;
|
||
}
|
||
|
||
public void SelectNode(NodeObject node, PointerEventData e)
|
||
{
|
||
bool multi = e != null && (e.button == PointerEventData.InputButton.Left);
|
||
bool shift = Keyboard.current != null && Keyboard.current.leftShiftKey.isPressed;
|
||
|
||
if (!shift)
|
||
{
|
||
foreach (var n in selectedNodes) n.Selected = false;
|
||
selectedNodes.Clear();
|
||
}
|
||
|
||
if (selectedNodes.Contains(node))
|
||
{
|
||
node.Selected = false;
|
||
selectedNodes.Remove(node);
|
||
}
|
||
else
|
||
{
|
||
node.Selected = true;
|
||
selectedNodes.Add(node);
|
||
}
|
||
}
|
||
|
||
// ========== 删除 ==========
|
||
void DeleteSelected()
|
||
{
|
||
// 1) 删选中线
|
||
for (int i = connections.Count - 1; i >= 0; i--)
|
||
{
|
||
var w = connections[i];
|
||
if (w.selected) RemoveConnection(w);
|
||
}
|
||
|
||
// 2) 删选中节点（含其关联线）
|
||
foreach (var node in selectedNodes.ToList())
|
||
{
|
||
for (int i = connections.Count - 1; i >= 0; i--)
|
||
{
|
||
if (connections[i].from?.ownerNode == node || connections[i].to?.ownerNode == node)
|
||
RemoveConnection(connections[i]);
|
||
}
|
||
allNodes.Remove(node);
|
||
Destroy(node.gameObject);
|
||
}
|
||
selectedNodes.Clear();
|
||
CleanupConnections();
|
||
}
|
||
|
||
void RemoveConnection(WireConnection w)
|
||
{
|
||
// 断开 out→in 数据连接
|
||
if (w.from?.connectorOut is OutputAny outAny && w.to?.connectorIn is InputAny inAny)
|
||
{
|
||
outAny.DisconnectAny(inAny);
|
||
inAny.DisconnectAny();
|
||
}
|
||
else if (w.from?.connectorOut is OutputAny outAny2 && w.to?.connectorIn != null)
|
||
{
|
||
// OutputAny → Input<T>: input 侧调 DisconnectAny
|
||
var inType = w.to.connectorIn.GetType();
|
||
if (inType.IsGenericType && inType.GetGenericTypeDefinition() == typeof(Input<>))
|
||
inType.GetMethod("DisconnectAny")?.Invoke(w.to.connectorIn, null);
|
||
}
|
||
else if (w.from?.connectorOut != null && w.to?.connectorIn is InputAny inAny2)
|
||
{
|
||
inAny2.DisconnectAny();
|
||
}
|
||
else if (w.from?.connectorOut != null && w.to?.connectorIn != null)
|
||
{
|
||
var outType = w.from.connectorOut.GetType();
|
||
var inType = w.to.connectorIn.GetType();
|
||
|
||
if (outType.IsGenericType && outType.GetGenericTypeDefinition() == typeof(Output<>))
|
||
{
|
||
var discMethod = outType.GetMethod("Disconnect", new[] { inType });
|
||
discMethod?.Invoke(w.from.connectorOut, new[] { w.to.connectorIn });
|
||
}
|
||
if (inType.IsGenericType && inType.GetGenericTypeDefinition() == typeof(Input<>))
|
||
{
|
||
var discMethod = inType.GetMethod("Disconnect", new[] { outType });
|
||
discMethod?.Invoke(w.to.connectorIn, new[] { w.from.connectorOut });
|
||
}
|
||
}
|
||
|
||
// 销毁线视觉
|
||
if (w.line != null) { if (w.line.gameObject != null) Destroy(w.line.gameObject); }
|
||
w.from = null; w.to = null; w.line = null;
|
||
connections.Remove(w);
|
||
}
|
||
|
||
void CleanupConnections()
|
||
{
|
||
for (int i = connections.Count - 1; i >= 0; i--)
|
||
{
|
||
var w = connections[i];
|
||
bool dead = w.from == null || w.to == null || w.line == null
|
||
|| w.from.ownerNode == null || w.to.ownerNode == null
|
||
|| w.from.connectorOut == null || w.to.connectorIn == null;
|
||
if (dead)
|
||
{
|
||
if (w.line != null && w.line.gameObject != null) Destroy(w.line.gameObject);
|
||
connections.RemoveAt(i);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ========== 保存 / 加载 ==========
|
||
|
||
[Serializable] public class GraphData { public string startElementGuid; public List<NodeData> nodes = new(); public List<WireData> wires = new(); }
|
||
[Serializable] public class NodeData { public string typeName; public float posX, posY; public List<FieldPair> fieldValues = new(); }
|
||
[Serializable] public class WireData { public int fromNodeIdx, toNodeIdx; public string fromOutput, toInput; }
|
||
[Serializable] public struct FieldPair { public string key; public string json; public FieldPair(string k, string j) { key = k; json = j; } }
|
||
|
||
static string SavePath => Application.streamingAssetsPath + "/NodeScript/";
|
||
static string SaveFile => SavePath + "graph.json";
|
||
|
||
public static string GetSavePath(string name) => SavePath + name + ".json";
|
||
|
||
public GraphData SaveGraph()
|
||
{
|
||
var g = new GraphData();
|
||
g.startElementGuid = startElement?.elementGuid.ToString();
|
||
var idxMap = new Dictionary<NodeObject, int>();
|
||
for (int i = 0; i < allNodes.Count; i++)
|
||
{
|
||
var n = allNodes[i]; idxMap[n] = i;
|
||
var nd = new NodeData
|
||
{
|
||
typeName = n.nodeBase.GetType().FullName,
|
||
posX = n.GetComponent<RectTransform>().anchoredPosition.x,
|
||
posY = n.GetComponent<RectTransform>().anchoredPosition.y
|
||
};
|
||
foreach (var f in n.nodeBase.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance))
|
||
{
|
||
if (typeof(IInput).IsAssignableFrom(f.FieldType) || typeof(IOutput).IsAssignableFrom(f.FieldType))
|
||
continue;
|
||
if (System.Attribute.IsDefined(f, typeof(NonSerializedAttribute))) continue;
|
||
nd.fieldValues.Add(new FieldPair(f.Name, JsonUtility.ToJson(f.GetValue(n.nodeBase))));
|
||
}
|
||
g.nodes.Add(nd);
|
||
}
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.from?.ownerNode == null || w.to?.ownerNode == null) continue;
|
||
g.wires.Add(new WireData
|
||
{
|
||
fromNodeIdx = idxMap.GetValueOrDefault(w.from.ownerNode, -1),
|
||
toNodeIdx = idxMap.GetValueOrDefault(w.to.ownerNode, -1),
|
||
fromOutput = w.from.connectorOut?.Name,
|
||
toInput = w.to.connectorIn?.Name
|
||
});
|
||
}
|
||
return g;
|
||
}
|
||
|
||
public void SaveToFile(string name = null)
|
||
{
|
||
string path = string.IsNullOrEmpty(name) ? SaveFile : GetSavePath(name);
|
||
System.IO.Directory.CreateDirectory(SavePath);
|
||
var json = JsonUtility.ToJson(SaveGraph(), true);
|
||
System.IO.File.WriteAllText(path, json);
|
||
Debug.Log("[NodeManager] Saved to " + path);
|
||
}
|
||
|
||
public void LoadFromFile(string name = null)
|
||
{
|
||
string path = string.IsNullOrEmpty(name) ? SaveFile : GetSavePath(name);
|
||
|
||
if (!System.IO.File.Exists(path))
|
||
{
|
||
Debug.LogWarning("[NodeManager] No save file at " + path);
|
||
return;
|
||
}
|
||
|
||
// 清空
|
||
foreach (var n in allNodes) Destroy(n.gameObject);
|
||
allNodes.Clear();
|
||
foreach (var w in connections) { if (w.line != null) Destroy(w.line.gameObject); }
|
||
connections.Clear();
|
||
selectedNodes.Clear();
|
||
|
||
var json = System.IO.File.ReadAllText(path);
|
||
var g = JsonUtility.FromJson<GraphData>(json);
|
||
|
||
// 重建节点
|
||
var newNodes = new List<NodeObject>();
|
||
foreach (var nd in g.nodes)
|
||
{
|
||
var type = Type.GetType(nd.typeName) ?? AppDomain.CurrentDomain.GetAssemblies()
|
||
.Select(a => a.GetType(nd.typeName)).FirstOrDefault(t => t != null);
|
||
if (type == null) { Debug.LogWarning("[NodeManager] Type not found: " + nd.typeName); continue; }
|
||
|
||
var data = (NodeBase)Activator.CreateInstance(type);
|
||
data.NodeName = type.Name;
|
||
data.InitConnectors();
|
||
|
||
// 恢复字段值
|
||
foreach (var fp in nd.fieldValues)
|
||
{
|
||
var f = type.GetField(fp.key, BindingFlags.Public | BindingFlags.Instance);
|
||
if (f != null && (f.FieldType.IsValueType || f.FieldType == typeof(string)))
|
||
try { f.SetValue(data, JsonUtility.FromJson(fp.json, f.FieldType)); } catch { }
|
||
}
|
||
|
||
var go = nodeObjectPrefab != null ? Instantiate(nodeObjectPrefab, transform) : new GameObject(data.NodeName, typeof(RectTransform));
|
||
var no = go.GetComponent<NodeObject>(); if (no == null) no = go.AddComponent<NodeObject>();
|
||
no.nodeBase = data;
|
||
go.GetComponent<RectTransform>().anchoredPosition = new Vector2(nd.posX, nd.posY);
|
||
no.Init(); allNodes.Add(no); newNodes.Add(no);
|
||
}
|
||
|
||
// 重建连线
|
||
foreach (var wd in g.wires)
|
||
{
|
||
if (wd.fromNodeIdx < 0 || wd.toNodeIdx < 0) continue;
|
||
if (wd.fromNodeIdx >= newNodes.Count || wd.toNodeIdx >= newNodes.Count) continue;
|
||
var srcSlots = newNodes[wd.fromNodeIdx].GetComponentsInChildren<ConnectorSlot>();
|
||
var dstSlots = newNodes[wd.toNodeIdx].GetComponentsInChildren<ConnectorSlot>();
|
||
var src = srcSlots.FirstOrDefault(s => !s.isInput && s.connectorOut?.Name == wd.fromOutput);
|
||
var dst = dstSlots.FirstOrDefault(s => s.isInput && s.connectorIn?.Name == wd.toInput);
|
||
if (src != null && dst != null) TryConnect(src, dst);
|
||
}
|
||
|
||
// 绑定 Start 节点的 element
|
||
var sel = EditorManager.instance?.operationManager?.currentSelectedElements;
|
||
if (sel != null && sel.Count > 0)
|
||
{
|
||
foreach (var n in allNodes)
|
||
{
|
||
if (n.nodeBase is NodeStart start)
|
||
{
|
||
start.boundElement = sel[0];
|
||
startElement = sel[0];
|
||
}
|
||
}
|
||
}
|
||
|
||
Debug.Log("[NodeManager] Loaded " + allNodes.Count + " nodes, " + connections.Count + " wires");
|
||
}
|
||
|
||
// ========== 复制 ==========
|
||
void CopySelected()
|
||
{
|
||
clipboard.nodes.Clear(); clipboard.wires.Clear();
|
||
var idxMap = new Dictionary<NodeObject, int>();
|
||
for (int i = 0; i < selectedNodes.Count; i++)
|
||
{
|
||
var node = selectedNodes[i]; idxMap[node] = i;
|
||
var fields = new Dictionary<string, object>();
|
||
foreach (var f in node.nodeBase.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance))
|
||
{
|
||
if (!typeof(IInput).IsAssignableFrom(f.FieldType) && !typeof(IOutput).IsAssignableFrom(f.FieldType))
|
||
fields[f.Name] = f.GetValue(node.nodeBase);
|
||
}
|
||
clipboard.nodes.Add((node.nodeBase.GetType(), fields));
|
||
}
|
||
// 复制选中节点之间的连线
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.selected || (w.from != null && w.to != null
|
||
&& selectedNodes.Contains(w.from.ownerNode) && selectedNodes.Contains(w.to.ownerNode)))
|
||
{
|
||
int fi = idxMap.GetValueOrDefault(w.from.ownerNode, -1);
|
||
int ti = idxMap.GetValueOrDefault(w.to.ownerNode, -1);
|
||
if (fi >= 0 && ti >= 0)
|
||
clipboard.wires.Add((fi, ti, w.from.connectorOut?.Name, w.to.connectorIn?.Name));
|
||
}
|
||
}
|
||
}
|
||
|
||
void PasteClipboard()
|
||
{
|
||
var pos = Mouse.current.position.ReadValue();
|
||
var newNodes = new List<NodeObject>();
|
||
foreach (var (type, fields) in clipboard.nodes)
|
||
{
|
||
var node = CreateNodeInstance(type, pos);
|
||
foreach (var kv in fields)
|
||
{
|
||
var f = type.GetField(kv.Key, BindingFlags.Public | BindingFlags.Instance);
|
||
if (f != null && f.FieldType == kv.Value?.GetType())
|
||
f.SetValue(node.nodeBase, kv.Value);
|
||
}
|
||
newNodes.Add(node);
|
||
pos += new Vector2(30, -30);
|
||
}
|
||
// 重连粘贴节点之间的线
|
||
foreach (var (fi, ti, outName, inName) in clipboard.wires)
|
||
{
|
||
if (fi >= newNodes.Count || ti >= newNodes.Count) continue;
|
||
var srcSlots = newNodes[fi].GetComponentsInChildren<ConnectorSlot>();
|
||
var dstSlots = newNodes[ti].GetComponentsInChildren<ConnectorSlot>();
|
||
var src = srcSlots.FirstOrDefault(s => !s.isInput && s.connectorOut?.Name == outName);
|
||
var dst = dstSlots.FirstOrDefault(s => s.isInput && s.connectorIn?.Name == inName);
|
||
if (src != null && dst != null) TryConnect(src, dst);
|
||
}
|
||
}
|
||
|
||
NodeObject CreateNodeInstance(Type nodeType, Vector2 screenPos, bool allowDuplicate = true)
|
||
{
|
||
// Start / Entry 全局唯一
|
||
if (!allowDuplicate && allNodes.Any(n => n.nodeBase.GetType() == nodeType))
|
||
{
|
||
Debug.LogWarning("[NodeManager] " + nodeType.Name + " already exists");
|
||
return null;
|
||
}
|
||
|
||
var data = (NodeBase)Activator.CreateInstance(nodeType);
|
||
data.NodeName = nodeType.Name;
|
||
data.InitConnectors();
|
||
GameObject go = nodeObjectPrefab != null ? Instantiate(nodeObjectPrefab, NodeArea) : new GameObject(data.NodeName, typeof(RectTransform));
|
||
var n = go.GetComponent<NodeObject>(); if (n == null) n = go.AddComponent<NodeObject>();
|
||
n.nodeBase = data;
|
||
RectTransform rt = go.GetComponent<RectTransform>();
|
||
var parentRt = NodeArea as RectTransform;
|
||
if (parentRt == null) parentRt = (RectTransform)transform;
|
||
RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRt, screenPos, refCamera, out var lp);
|
||
rt.anchoredPosition = lp;
|
||
n.Init(); allNodes.Add(n);
|
||
return n;
|
||
}
|
||
|
||
// ---- coord ----
|
||
Vector2 ToLocal(RectTransform rt)
|
||
{
|
||
Vector2 screen;
|
||
if (canvas == null || canvas.renderMode == RenderMode.ScreenSpaceOverlay) screen = rt.position;
|
||
else screen = RectTransformUtility.WorldToScreenPoint(canvas.worldCamera, rt.position);
|
||
RectTransformUtility.ScreenPointToLocalPointInRectangle(canvas.transform as RectTransform, screen, canvas.worldCamera, out Vector2 local);
|
||
return local;
|
||
}
|
||
Vector2 ToLocal(Vector2 sp) { RectTransformUtility.ScreenPointToLocalPointInRectangle(canvas.transform as RectTransform, sp, canvas.worldCamera, out var l); return l; }
|
||
|
||
// ---- wire drag ----
|
||
public void StartWireDrag(ConnectorSlot slot, PointerEventData e)
|
||
{
|
||
if (slot.isInput || slot.connectorOut == null) return;
|
||
dragSource = slot; isDraggingWire = true;
|
||
dragLine.color = slot.connectorOut.ConnectorColor;
|
||
dragLine.gameObject.SetActive(true);
|
||
dragLine.Points = new[] { ToLocal(slot.connectorRect), ToLocal(e.position) };
|
||
}
|
||
public void UpdateWireDrag(PointerEventData e) { if (isDraggingWire) dragLine.Points = new[] { ToLocal(dragSource.connectorRect), ToLocal(e.position) }; }
|
||
public void EndWireDrag(PointerEventData e)
|
||
{
|
||
if (!isDraggingWire) return;
|
||
dragLine.gameObject.SetActive(false);
|
||
var t = HitTestSlot(e, true);
|
||
if (t != null && t != dragSource) TryConnect(dragSource, t);
|
||
dragSource = null; isDraggingWire = false;
|
||
}
|
||
|
||
// ---- connect ----
|
||
void TryConnect(ConnectorSlot src, ConnectorSlot dst)
|
||
{
|
||
if (src.connectorOut == null || dst.connectorIn == null) return;
|
||
if (src.ownerNode == dst.ownerNode) return;
|
||
|
||
// 环检测：从 dst 出发沿已有连线 DFS，看能否回到 src
|
||
if (WouldCreateCycle(src.ownerNode.nodeBase, dst.ownerNode.nodeBase))
|
||
{
|
||
Debug.LogWarning($"[NodeManager] Connection rejected: would create cycle ({src.ownerNode.nodeBase.NodeName} -> {dst.ownerNode.nodeBase.NodeName})");
|
||
return;
|
||
}
|
||
|
||
// 类型检查：处理 InputAny / OutputAny
|
||
var outType = src.connectorOut.DataType;
|
||
var inType = dst.connectorIn.DataType;
|
||
|
||
// InputAny 未锁定 → 允许连接，锁定类型
|
||
if (dst.connectorIn is InputAny inAny && inAny.DataType == null)
|
||
{
|
||
// OK: 类型将从 src 锁定
|
||
}
|
||
// InputAny 已锁定 → 检查兼容
|
||
else if (dst.connectorIn is InputAny inAnyLocked && inAnyLocked.DataType != null)
|
||
{
|
||
if (!TypesCompatible(outType, inAnyLocked.DataType))
|
||
{
|
||
Debug.LogWarning($"[NodeManager] Type mismatch: {outType?.Name} -> InputAny(locked={inAnyLocked.DataType.Name})");
|
||
return;
|
||
}
|
||
}
|
||
// 标准泛型端口 → 兼容匹配
|
||
else if (!TypesCompatible(outType, inType))
|
||
{
|
||
Debug.LogWarning($"[NodeManager] Type mismatch: {outType?.Name} != {inType?.Name}");
|
||
return;
|
||
}
|
||
|
||
// 实际连接
|
||
if (src.connectorOut is OutputAny outAny && dst.connectorIn is InputAny inAny2)
|
||
{
|
||
outAny.ConnectAny(inAny2);
|
||
inAny2.ConnectAny(outAny);
|
||
}
|
||
else if (src.connectorOut is OutputAny outAny3)
|
||
{
|
||
var inT = dst.connectorIn.GetType();
|
||
if (inT.IsGenericType && inT.GetGenericTypeDefinition() == typeof(Input<>))
|
||
{
|
||
// OutputAny → Input<T>: 通过 ConnectAny 桥接
|
||
var connectAny = inT.GetMethod("ConnectAny", new[] { typeof(IOutput) });
|
||
connectAny?.Invoke(dst.connectorIn, new[] { (IOutput)outAny3 });
|
||
}
|
||
else
|
||
{
|
||
outAny3.ConnectAny(dst.connectorIn as InputAny);
|
||
(dst.connectorIn as InputAny)?.ConnectAny(outAny3);
|
||
}
|
||
}
|
||
else if (dst.connectorIn is InputAny inAny4)
|
||
{
|
||
// Output<T> → InputAny
|
||
inAny4.ConnectAny(src.connectorOut);
|
||
}
|
||
else
|
||
{
|
||
// Standard Output<T> → Input<T>
|
||
var outReal = src.connectorOut.GetType();
|
||
var inReal = dst.connectorIn.GetType();
|
||
|
||
var connectMethod = outReal.GetMethods(BindingFlags.Instance | BindingFlags.Public)
|
||
.FirstOrDefault(m => m.Name == "Connect" && m.GetParameters().Length == 1);
|
||
var connectInMethod = inReal.GetMethods(BindingFlags.Instance | BindingFlags.Public)
|
||
.FirstOrDefault(m => m.Name == "Connect" && m.GetParameters().Length == 1);
|
||
|
||
if (connectMethod == null || connectInMethod == null)
|
||
{
|
||
Debug.LogError($"[Wire] Reflection failed: {outReal.Name}.Connect({inReal.Name})");
|
||
return;
|
||
}
|
||
|
||
connectMethod.Invoke(src.connectorOut, new[] { dst.connectorIn });
|
||
connectInMethod.Invoke(dst.connectorIn, new[] { src.connectorOut });
|
||
}
|
||
|
||
// 刷新连接点外观（InputAny 锁定后颜色会变）
|
||
dst.RefreshAppearance();
|
||
|
||
var line = CreateWire("W_" + connections.Count, src.connectorOut.ConnectorColor);
|
||
line.gameObject.SetActive(true);
|
||
var pts = new[] { ToLocal(src.connectorRect), ToLocal(dst.connectorRect) };
|
||
line.Points = pts;
|
||
FitRectToLine(line, pts);
|
||
connections.Add(new WireConnection { from = src, to = dst, line = line });
|
||
|
||
// 连线后重算 L
|
||
ComputeLValues();
|
||
}
|
||
|
||
ConnectorSlot HitTestSlot(PointerEventData e, bool isInput)
|
||
{
|
||
var r = new List<RaycastResult>(); EventSystem.current.RaycastAll(e, r);
|
||
return r.Select(x => x.gameObject.GetComponent<ConnectorSlot>()).FirstOrDefault(s => s != null && s.isInput == isInput && (isInput ? s.connectorIn != null : s.connectorOut != null));
|
||
}
|
||
|
||
public void RefreshAllLines()
|
||
{
|
||
foreach (var w in connections)
|
||
if (w.from != null && w.to != null)
|
||
{
|
||
var pts = new[] { ToLocal(w.from.connectorRect), ToLocal(w.to.connectorRect) };
|
||
w.line.Points = pts;
|
||
FitRectToLine(w.line, pts);
|
||
}
|
||
}
|
||
|
||
void FitRectToLine(UILineRenderer line, Vector2[] pts)
|
||
{
|
||
if (pts.Length < 2) return;
|
||
var rt = line.GetComponent<RectTransform>();
|
||
|
||
var min = pts[0]; var max = pts[0];
|
||
for (int i = 1; i < pts.Length; i++)
|
||
{
|
||
min = Vector2.Min(min, pts[i]);
|
||
max = Vector2.Max(max, pts[i]);
|
||
}
|
||
|
||
float pad = wireThickness + 4f;
|
||
Vector2 offset = min - new Vector2(pad, pad);
|
||
|
||
// 将 Points 从 canvas 绝对坐标转为相对 RectTransform 的局部坐标
|
||
var localPts = new Vector2[pts.Length];
|
||
for (int i = 0; i < pts.Length; i++)
|
||
localPts[i] = pts[i] - offset;
|
||
line.Points = localPts;
|
||
|
||
rt.anchoredPosition = offset;
|
||
rt.sizeDelta = max - min + new Vector2(pad * 2f, pad * 2f);
|
||
}
|
||
|
||
UILineRenderer CreateWire(string n, Color c)
|
||
{
|
||
var g = new GameObject(n, typeof(RectTransform));
|
||
g.transform.SetParent(canvas.transform, false);
|
||
|
||
var l = g.AddComponent<UILineRenderer>(); l.color = c; l.LineThickness = wireThickness;
|
||
l.RelativeSize = false; l.BezierMode = UILineRenderer.BezierType.Quick;
|
||
l.Points = new Vector2[] { Vector2.zero, Vector2.zero };
|
||
l.raycastTarget = false;
|
||
var h = g.AddComponent<WireClickHandler>();
|
||
h.mgr = this; h.line = l;
|
||
return l;
|
||
}
|
||
|
||
public void ToggleWireSelection(UILineRenderer line, bool shift)
|
||
{
|
||
var wc = connections.Find(w => w.line == line);
|
||
if (wc == null) return;
|
||
if (!shift) { foreach (var w in connections) w.selected = false; }
|
||
wc.selected = !wc.selected;
|
||
}
|
||
|
||
WireConnection UpdateWireHover()
|
||
{
|
||
var canvasMouse = ToLocal(Mouse.current.position.ReadValue());
|
||
float hoverThreshold = wireThickness + 6f;
|
||
|
||
WireConnection hovered = null;
|
||
float bestDist = hoverThreshold;
|
||
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.line == null) continue;
|
||
var pts = w.line.Points;
|
||
if (pts == null || pts.Length < 2) continue;
|
||
var rtPos = w.line.GetComponent<RectTransform>().anchoredPosition;
|
||
|
||
for (int i = 1; i < pts.Length; i++)
|
||
{
|
||
float d = DistToSegment(canvasMouse, rtPos + pts[i - 1], rtPos + pts[i]);
|
||
if (d < bestDist) { bestDist = d; hovered = w; }
|
||
}
|
||
}
|
||
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.line == null) continue;
|
||
w.line.LineThickness = w.selected ? wireThickness * 2f
|
||
: (w == hovered) ? wireThickness + 3f
|
||
: wireThickness;
|
||
}
|
||
|
||
if (Mouse.current.leftButton.wasPressedThisFrame && hovered != null)
|
||
ToggleWireSelection(hovered.line, Keyboard.current.leftShiftKey.isPressed);
|
||
|
||
return Mouse.current.leftButton.wasPressedThisFrame ? hovered : null;
|
||
}
|
||
|
||
static float DistToSegment(Vector2 p, Vector2 a, Vector2 b)
|
||
{
|
||
Vector2 ab = b - a;
|
||
float lenSq = ab.sqrMagnitude;
|
||
if (lenSq < 0.001f) return Vector2.Distance(p, a);
|
||
float t = Mathf.Clamp01(Vector2.Dot(p - a, ab) / lenSq);
|
||
return Vector2.Distance(p, a + t * ab);
|
||
}
|
||
|
||
// ---- 单步调试 ----
|
||
void DebugInit()
|
||
{
|
||
_debugMode = true;
|
||
_debugStep = 0;
|
||
_dirtyElements.Clear();
|
||
ComputeLValues();
|
||
|
||
foreach (var n in allNodes)
|
||
n.nodeBase.Status = NodeStatus.Ready;
|
||
|
||
triggerTable.Clear();
|
||
runtimeTable.Clear();
|
||
foreach (var n in allNodes)
|
||
triggerTable.Add(n.nodeBase);
|
||
|
||
UpdateAllStatusDisplay();
|
||
Debug.Log($"[NodeManager] Debug init — {allNodes.Count} nodes ready. Shift+Enter to step.");
|
||
}
|
||
|
||
void DebugStep()
|
||
{
|
||
if (!_debugMode) return;
|
||
if (triggerTable.Count == 0 && runtimeTable.Count == 0)
|
||
{
|
||
Debug.Log($"[NodeManager] Debug done — all nodes completed in {_debugStep} steps.");
|
||
DebugReset();
|
||
return;
|
||
}
|
||
|
||
// 记录本周期开始前 runtime 中的节点
|
||
var before = new HashSet<NodeBase>(runtimeTable);
|
||
|
||
_debugStep++;
|
||
RunCycle();
|
||
|
||
// 详细日志
|
||
var sb = new System.Text.StringBuilder();
|
||
sb.AppendLine($"<color=cyan>=== Step {_debugStep} ===</color>");
|
||
foreach (var n in before)
|
||
{
|
||
var icon = n.Status == NodeStatus.Complete ? "✓" : n.Status == NodeStatus.Hang ? "⏳" : "▶";
|
||
var color = n.Status == NodeStatus.Complete ? "green" : n.Status == NodeStatus.Hang ? "yellow" : "white";
|
||
sb.AppendLine($" {icon} <color={color}>{n.NodeName}</color> (L:{n.L}) → {n.Status}");
|
||
}
|
||
sb.AppendLine($" triggers pending: {triggerTable.Count}, still running: {runtimeTable.Count}");
|
||
Debug.Log(sb.ToString());
|
||
|
||
UpdateAllStatusDisplay();
|
||
|
||
if (triggerTable.Count == 0 && runtimeTable.Count == 0)
|
||
{
|
||
Observable.NextFrame(FrameCountType.EndOfFrame)
|
||
.Subscribe(_ =>
|
||
{
|
||
foreach (var e in _dirtyElements)
|
||
if (e is IBaseElement be) be.Refresh();
|
||
_dirtyElements.Clear();
|
||
});
|
||
}
|
||
}
|
||
|
||
void DebugReset()
|
||
{
|
||
_debugMode = false;
|
||
_debugStep = 0;
|
||
triggerTable.Clear();
|
||
runtimeTable.Clear();
|
||
foreach (var n in allNodes)
|
||
n.nodeBase.Status = NodeStatus.Ready;
|
||
UpdateAllStatusDisplay();
|
||
Debug.Log("[NodeManager] Debug reset.");
|
||
}
|
||
|
||
void PreviewOrder()
|
||
{
|
||
ComputeLValues();
|
||
|
||
var byLayer = allNodes.GroupBy(n => n.nodeBase.L)
|
||
.OrderBy(g => g.Key)
|
||
.ToList();
|
||
|
||
var sb = new System.Text.StringBuilder();
|
||
sb.AppendLine("<color=cyan>═══ Topological Order (BFS layers) ═══</color>");
|
||
|
||
foreach (var layer in byLayer)
|
||
{
|
||
var names = string.Join(", ", layer.Select(n => $"{n.nodeBase.NodeName}(L:{n.nodeBase.L})"));
|
||
var fanOut = layer.Sum(n => connections.Count(w => w.from?.ownerNode == n));
|
||
sb.AppendLine($" <color=yellow>Layer {layer.Key}</color> ({layer.Count()} nodes, {fanOut} downstream wires): {names}");
|
||
}
|
||
|
||
var isolated = allNodes.Where(n => n.nodeBase.L < 0).ToList();
|
||
if (isolated.Count > 0)
|
||
{
|
||
sb.AppendLine($" <color=red>Unreachable</color> ({isolated.Count} nodes): {string.Join(", ", isolated.Select(n => n.nodeBase.NodeName))}");
|
||
}
|
||
|
||
var totalConnections = connections.Count;
|
||
var cycles = totalConnections - (allNodes.Count - isolated.Count); // rough estimate
|
||
sb.AppendLine($" Total: {allNodes.Count} nodes, {totalConnections} wires, {byLayer.Count} layers");
|
||
|
||
Debug.Log(sb.ToString());
|
||
UpdateAllStatusDisplay();
|
||
}
|
||
|
||
void UpdateAllStatusDisplay()
|
||
{
|
||
foreach (var n in allNodes)
|
||
n.UpdateStatusDisplay();
|
||
}
|
||
|
||
// ---- run (lifecycle) ----
|
||
public void RunGraph()
|
||
{
|
||
_dirtyElements.Clear();
|
||
ComputeLValues();
|
||
|
||
triggerTable.Clear();
|
||
runtimeTable.Clear();
|
||
|
||
// 所有节点初始进入触发表
|
||
foreach (var n in allNodes)
|
||
{
|
||
n.nodeBase.Status = NodeStatus.Ready;
|
||
triggerTable.Add(n.nodeBase);
|
||
}
|
||
|
||
Debug.Log("[NodeManager] === START (lifecycle) ===");
|
||
|
||
int maxIter = 10000;
|
||
int iter = 0;
|
||
while ((triggerTable.Count > 0 || runtimeTable.Count > 0) && iter++ < maxIter)
|
||
RunCycle();
|
||
|
||
if (iter >= maxIter)
|
||
Debug.LogWarning("[NodeManager] exceeded max iterations — possible infinite loop");
|
||
else
|
||
Debug.Log($"<color=green>[NodeManager] Run complete — {iter} cycles, {allNodes.Count(n => n.nodeBase.Status == NodeStatus.Complete)} nodes completed</color>");
|
||
|
||
// 统一 Refresh 脏元素
|
||
UpdateAllStatusDisplay();
|
||
Observable.NextFrame(FrameCountType.EndOfFrame)
|
||
.Subscribe(_ =>
|
||
{
|
||
foreach (var e in _dirtyElements)
|
||
if (e is IBaseElement be) be.Refresh();
|
||
_dirtyElements.Clear();
|
||
});
|
||
}
|
||
|
||
void RunCycle()
|
||
{
|
||
// 触发表并入运行时表
|
||
foreach (var t in triggerTable)
|
||
{
|
||
if (t.Status == NodeStatus.Complete) continue;
|
||
t.Status = NodeStatus.Ready;
|
||
runtimeTable.Add(t);
|
||
}
|
||
triggerTable.Clear();
|
||
|
||
var toRemove = new List<NodeBase>();
|
||
|
||
foreach (var node in runtimeTable)
|
||
{
|
||
if (node.Status == NodeStatus.Complete)
|
||
{
|
||
toRemove.Add(node);
|
||
continue;
|
||
}
|
||
|
||
var result = node.Loop();
|
||
|
||
if (result.Triggers != null)
|
||
{
|
||
foreach (var t in result.Triggers)
|
||
triggerTable.Add(t);
|
||
}
|
||
|
||
if (result.TriggerDownstream)
|
||
{
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.from?.ownerNode?.nodeBase == node && w.to?.ownerNode?.nodeBase != null)
|
||
{
|
||
var downstream = w.to.ownerNode.nodeBase;
|
||
if (downstream.Status != NodeStatus.Complete)
|
||
triggerTable.Add(downstream);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (result.RemoveFromRuntime)
|
||
{
|
||
node.Status = NodeStatus.Complete;
|
||
toRemove.Add(node);
|
||
}
|
||
}
|
||
|
||
foreach (var r in toRemove)
|
||
runtimeTable.Remove(r);
|
||
}
|
||
|
||
/// <summary>BFS 计算所有节点到 Start 的最短距离 L，仅用于显示</summary>
|
||
public void ComputeLValues()
|
||
{
|
||
foreach (var n in allNodes)
|
||
n.nodeBase.L = -1;
|
||
|
||
var queue = new Queue<NodeBase>();
|
||
foreach (var n in allNodes)
|
||
{
|
||
if (n.nodeBase is NodeStart || n.nodeBase is NodeEntry)
|
||
{
|
||
n.nodeBase.L = 0;
|
||
queue.Enqueue(n.nodeBase);
|
||
}
|
||
}
|
||
|
||
while (queue.Count > 0)
|
||
{
|
||
var cur = queue.Dequeue();
|
||
int nextL = cur.L + 1;
|
||
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.from?.ownerNode?.nodeBase == cur && w.to?.ownerNode?.nodeBase != null)
|
||
{
|
||
var downstream = w.to.ownerNode.nodeBase;
|
||
if (downstream.L == -1)
|
||
{
|
||
downstream.L = nextL;
|
||
queue.Enqueue(downstream);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 刷新所有节点标题显示 L 值
|
||
foreach (var n in allNodes)
|
||
n.UpdateLDisplay();
|
||
}
|
||
|
||
static bool IsNumeric(Type t) => t == typeof(float) || t == typeof(int);
|
||
static bool TypesCompatible(Type from, Type to)
|
||
{
|
||
if (from == null || to == null) return true; // untyped → allow
|
||
if (from == to) return true;
|
||
if (IsNumeric(from) && IsNumeric(to)) return true; // int ↔ float
|
||
return false;
|
||
}
|
||
|
||
/// <summary>尝试添加 from→to 边是否会成环：从 to 出发 DFS，看能否回到 from</summary>
|
||
bool WouldCreateCycle(NodeBase from, NodeBase to)
|
||
{
|
||
if (from == null || to == null) return true;
|
||
var visited = new HashSet<NodeBase>();
|
||
var stack = new Stack<NodeBase>();
|
||
stack.Push(to);
|
||
|
||
while (stack.Count > 0)
|
||
{
|
||
var cur = stack.Pop();
|
||
if (cur == from) return true;
|
||
if (!visited.Add(cur)) continue;
|
||
|
||
foreach (var w in connections)
|
||
{
|
||
if (w.from?.ownerNode?.nodeBase == cur && w.to?.ownerNode?.nodeBase != null)
|
||
stack.Push(w.to.ownerNode.nodeBase);
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ---- context menu ----
|
||
RectTransform _menuContent;
|
||
|
||
string _searchFilter = "";
|
||
|
||
void EnsureScrollMenu()
|
||
{
|
||
if (contextMenuRoot == null) return;
|
||
if (_menuContent != null) return;
|
||
|
||
var rootRt = contextMenuRoot as RectTransform;
|
||
rootRt.sizeDelta = new Vector2(350, 850);
|
||
|
||
var scroll = contextMenuRoot.gameObject.GetComponent<ScrollRect>();
|
||
if (scroll == null) scroll = contextMenuRoot.gameObject.AddComponent<ScrollRect>();
|
||
var mask = contextMenuRoot.gameObject.GetComponent<Mask>();
|
||
if (mask == null) mask = contextMenuRoot.gameObject.AddComponent<Mask>();
|
||
var img = contextMenuRoot.gameObject.GetComponent<Image>();
|
||
if (img == null) { img = contextMenuRoot.gameObject.AddComponent<Image>(); img.color = new Color(0.1f, 0.1f, 0.1f, 0.95f); }
|
||
|
||
// ---- 搜索栏（固定在顶部，不随滚动）----
|
||
if (uiInputPrefab != null)
|
||
{
|
||
var searchGo = Instantiate(uiInputPrefab, contextMenuRoot);
|
||
searchGo.name = "Search";
|
||
var searchRt = searchGo.GetComponent<RectTransform>();
|
||
searchRt.anchorMin = new Vector2(0, 1); searchRt.anchorMax = new Vector2(1, 1);
|
||
searchRt.pivot = new Vector2(0.5f, 1);
|
||
searchRt.anchoredPosition = new Vector2(0, -5);
|
||
searchRt.sizeDelta = new Vector2(-10, 30);
|
||
var searchInput = searchGo.GetComponentInChildren<TMP_InputField>();
|
||
if (searchInput != null)
|
||
{
|
||
searchInput.onValueChanged.AddListener(v =>
|
||
{
|
||
_searchFilter = v;
|
||
BuildContextMenu();
|
||
});
|
||
}
|
||
}
|
||
|
||
// ---- 滚动区域 ----
|
||
var viewport = new GameObject("Viewport", typeof(RectTransform), typeof(Image), typeof(Mask));
|
||
viewport.transform.SetParent(contextMenuRoot, false);
|
||
var vpRt = viewport.GetComponent<RectTransform>();
|
||
vpRt.anchorMin = new Vector2(0, 0); vpRt.anchorMax = new Vector2(1, 1);
|
||
vpRt.offsetMin = new Vector2(0, 0); vpRt.offsetMax = new Vector2(0, -40); // 给搜索栏让位
|
||
|
||
var content = new GameObject("Content", typeof(RectTransform), typeof(VerticalLayoutGroup), typeof(ContentSizeFitter));
|
||
content.transform.SetParent(viewport.transform, false);
|
||
var ctRt = content.GetComponent<RectTransform>();
|
||
ctRt.anchorMin = new Vector2(0, 1); ctRt.anchorMax = new Vector2(1, 1);
|
||
ctRt.pivot = new Vector2(0.5f, 1); ctRt.sizeDelta = new Vector2(0, 0);
|
||
var vlg = content.GetComponent<VerticalLayoutGroup>();
|
||
vlg.childForceExpandWidth = true; vlg.childForceExpandHeight = false;
|
||
vlg.childControlWidth = true; vlg.childControlHeight = false;
|
||
var csf = content.GetComponent<ContentSizeFitter>();
|
||
csf.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
|
||
|
||
scroll.viewport = vpRt;
|
||
scroll.content = ctRt;
|
||
scroll.horizontal = false;
|
||
scroll.vertical = true;
|
||
_menuContent = ctRt;
|
||
}
|
||
|
||
void TryShowContextMenu(Vector2 sp)
|
||
{
|
||
if (canvasArea == null || contextMenuRoot == null) return;
|
||
if (!RectTransformUtility.RectangleContainsScreenPoint(canvasArea, sp, refCamera)) return;
|
||
EnsureScrollMenu();
|
||
_searchFilter = "";
|
||
BuildContextMenu();
|
||
RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)contextMenuRoot.parent, sp, refCamera, out var lp);
|
||
contextMenuRoot.gameObject.SetActive(true);
|
||
(contextMenuRoot as RectTransform).anchoredPosition = lp;
|
||
}
|
||
|
||
void BuildContextMenu()
|
||
{
|
||
if (contextMenuRoot == null || _menuContent == null) return;
|
||
foreach (Transform t in _menuContent) Destroy(t.gameObject);
|
||
|
||
GetNodeTypes(); // ensure cached
|
||
var filter = _searchFilter?.ToLower() ?? "";
|
||
|
||
foreach (var nt in _cachedSorted)
|
||
{
|
||
if (!string.IsNullOrEmpty(filter) && !nt.Value.ToLower().Contains(filter)) continue;
|
||
|
||
var item = Instantiate(contextMenuItemPrefab, _menuContent);
|
||
var l = item.GetComponentInChildren<TMP_Text>(); if (l != null) l.text = nt.Value;
|
||
var b = item.GetComponentInChildren<Button>();
|
||
if (b != null) { var tt = nt.Key; b.onClick.AddListener(() => { CreateNode(tt, Mouse.current.position.ReadValue()); contextMenuRoot.gameObject.SetActive(false); }); }
|
||
}
|
||
}
|
||
|
||
void CreateNode(Type nodeType, Vector2 sp)
|
||
{
|
||
bool dup = nodeType != typeof(NodeStart) && nodeType != typeof(NodeEntry);
|
||
CreateNodeInstance(nodeType, sp, dup);
|
||
}
|
||
|
||
static readonly Type[] GenericExpandTypes = { typeof(float), typeof(int), typeof(Vector2), typeof(Vector3), typeof(GameElement), typeof(List<GameElement>) };
|
||
static Dictionary<Type, string> _cachedTypes;
|
||
static List<KeyValuePair<Type, string>> _cachedSorted;
|
||
|
||
static Dictionary<Type, string> GetNodeTypes()
|
||
{
|
||
if (_cachedTypes != null) return _cachedTypes;
|
||
var d = new Dictionary<Type, string>();
|
||
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
|
||
{
|
||
Type[] ts; try { ts = a.GetTypes(); } catch { continue; }
|
||
foreach (var t in ts)
|
||
{
|
||
if (t.IsAbstract || !typeof(NodeBase).IsAssignableFrom(t)) continue;
|
||
if (t.IsGenericTypeDefinition)
|
||
{ foreach (var T in GenericExpandTypes) { var c = t.MakeGenericType(T); d[c] = t.Name.Split('`')[0] + "<" + T.Name + ">"; } }
|
||
else { var nm = t.Name; if (t.IsGenericType) nm = t.Name.Split('`')[0] + "<" + string.Join(",", t.GetGenericArguments().Select(a => a.Name)) + ">"; d[t] = nm; }
|
||
}
|
||
}
|
||
_cachedTypes = d;
|
||
_cachedSorted = d.OrderBy(kv => kv.Value).ToList();
|
||
return d;
|
||
}
|
||
}
|
||
|
||
class WireClickHandler : MonoBehaviour
|
||
{
|
||
public NodeManager mgr;
|
||
public UILineRenderer line;
|
||
}
|
||
}
|