/// <summary> 连接节点 </summary>
IEnumerator LinkNodeViews()
{
int step = 0;
foreach (var connection in Model.Connections)
{
if (connection == null)
{
continue;
}
BaseNodeView fromNodeView, toNodeView;
if (!NodeViews.TryGetValue(connection.FromNodeGUID, out fromNodeView))
{
throw new NullReferenceException($"找不到From节点{connection.FromNodeGUID}");
}
if (!NodeViews.TryGetValue(connection.ToNodeGUID, out toNodeView))
{
throw new NullReferenceException($"找不到To节点{connection.ToNodeGUID}");
}
ConnectView(fromNodeView, toNodeView, connection);
step++;
if (step % 5 == 0)
{
yield return(null);
}
}
}
public StateHelper()
{
Settings = new BL.DummySettings();
ApiHandler = new BL.ApiHandler(Settings);
NodeStore = new BL.NodeStore();
WebSocketHandler = new BL.WebSocketHelper(Settings.WebSocketUri);
var nodeType = typeof(INode);
var types = this.GetType().Assembly.GetExportedTypes();
foreach (var t in types)
{
if (nodeType.IsAssignableFrom(t))
{
var attr = t.GetCustomAttributes(typeof(NodeFeatureAttribute), true).OfType <NodeFeatureAttribute>().FirstOrDefault();
if (attr != null)
{
NodeTypes.Add(attr.Features, t);
}
}
if (nodeType.IsAssignableFrom(t))
{
var attr = t.GetCustomAttributes(typeof(NodeViewAttribute), true).OfType <NodeViewAttribute>().FirstOrDefault();
if (attr != null)
{
NodeViews.Add(attr.NodeType, t);
}
}
}
}
public ChainNodeView FindChainNodeView(ChainNode node, bool recurse)
{
var foundNode = NodeViews.FirstOrDefault(view => view.ChainNode == node);
if (foundNode != null)
{
return(foundNode);
}
if (!recurse)
{
return(null);
}
foreach (var view in GroupViews)
{
foundNode = view.FindChainNodeView(node, true);
if (foundNode != null)
{
return(foundNode);
}
}
return(null);
}
public void RefreshDirtyState()
{
if (ChainView.Instance.IsBusy)
{
return;
}
if (TimelineViewBehaviour.Instance == null)
{
return;
}
if (TimelineViewBehaviour.Instance.Timeline.IsBusy)
{
return;
}
if (HaxxisGlobalSettings.Instance.IsVgsJob == true)
{
return;
}
if (HaxxisGlobalSettings.Instance.DisableEditor == true)
{
return;
}
if (string.IsNullOrEmpty(LoadedPackagePath))
{
var hasChildren = GroupViews.Any() || NodeViews.Any();
DirtyIndicatorComponent.gameObject.SetActive(hasChildren);
return;
}
try
{
ChainGroup.SerializingGroup = Group;
var hp = ChainView.GetHaxxisPackageForGroupView(this);
var hasChanged = HaxxisPackage.IsChanged(hp, LoadedPackagePath);
DirtyIndicatorComponent.gameObject.SetActive(hasChanged);
}
finally
{
ChainGroup.SerializingGroup = null;
}
}
private void HandleNodeViewDropped(ChainNodeView droppedNodeView)
{
if (!ChainView.GroupTransferModeActive)
{
return;
}
Debug.Log("node view dropped");
if (NodeViews.Contains(droppedNodeView))
{
return;
}
droppedNodeView.RequestTransfer(this);
}
private void RemoveChainNodeView(ChainNodeView view, bool destroy)
{
view.BoundsChanged -= HandleChildViewBoundsChanged;
view.TransferRequested -= HandleChildNodeViewTransferRequested;
view.DuplicationRequested -= HandleNodeViewDuplicationRequested;
NodeViews.Remove(view);
if (destroy)
{
Destroy(view.gameObject);
}
BoundsDirty = true;
UpdateDeleteButtonState();
}
private void HandlePreviewNodeViewDrop(ChainNodeView nodeView)
{
if (!ChainView.GroupTransferModeActive)
{
return;
}
if (nodeView == null)
{
IndicateDropAcceptance(false);
return;
}
if (NodeViews.Contains(nodeView))
{
IndicateDropAcceptance(false);
return;
}
IndicateDropAcceptance(true);
}
private void RemoveChainNodeView(ChainNode node, bool destroy)
{
if (ChainView.SelectedChainNode == node)
{
ChainView.SelectedChainNode = null;
}
if (node.Router.SelectionStatesEnumerable.Contains(ChainView.SelectedSelectionState))
{
ChainView.SelectedSelectionState = null;
}
var view = NodeViews.FirstOrDefault(nv => nv.ChainNode == node);
if (view == null)
{
return;
}
RemoveChainNodeView(view, destroy);
}
private void AddChainNodeView(ChainNodeView view, bool isTransfer = false)
{
if (isTransfer)
{
view.transform.SetParent(NodeAttachmentPoint, true);
}
NodeViews.Add(view);
if (!isTransfer)
{
view.transform.position = NewNodePosition;
}
view.BoundsChanged += HandleChildViewBoundsChanged;
view.TransferRequested += HandleChildNodeViewTransferRequested;
view.DuplicationRequested += HandleNodeViewDuplicationRequested;
BoundsDirty = true;
UpdateDeleteButtonState();
}
/// <summary> 连接节点 </summary>
IEnumerator LinkNodeViews()
{
foreach (var serializedEdge in Model.Edges)
{
yield return(0);
if (serializedEdge.Value == null)
{
continue;
}
BaseNodeView inputNodeView, outputNodeView;
if (!NodeViews.TryGetValue(serializedEdge.Value.InputNodeGUID, out inputNodeView))
{
yield break;
}
if (!NodeViews.TryGetValue(serializedEdge.Value.OutputNodeGUID, out outputNodeView))
{
yield break;
}
ConnectView(inputNodeView.PortViews[serializedEdge.Value.InputFieldName]
, outputNodeView.PortViews[serializedEdge.Value.OutputFieldName]
, serializedEdge.Value);
}
}
public void RemoveNodeView(BaseNodeView _nodeView)
{
RemoveElement(_nodeView);
NodeViews.Remove(_nodeView.Model.GUID);
}
void DeserializeAndPasteCallback(string _operationName, string _serializedData)
{
ClearSelection();
var data = SerializationUtility.DeserializeValue <ClipBoard>(Encoding.UTF8.GetBytes(_serializedData), DataFormat.JSON, ClipBoard.objectReferences);
Dictionary <string, BaseNode> copiedNodesMap = new Dictionary <string, BaseNode>();
foreach (var node in data.copiedNodes)
{
if (node == null)
{
continue;
}
string sourceGUID = node.GUID;
// 新节点重置id
BaseNode.IDAllocation(node);
// 新节点与旧id存入字典
copiedNodesMap[sourceGUID] = node;
Model.AddNode(node).ClearConnectionsWithoutNotification();
node.Position += new Vector2(20, 20);
AddToSelection(NodeViews[node.GUID]);
}
foreach (var group in data.copiedGroups)
{
group.Position = new Rect(new Vector2(20, 20), group.Position.size);
var oldGUIDList = group.InnerNodeGUIDs.ToList();
group.InnerNodeGUIDs.Clear();
foreach (var guid in oldGUIDList)
{
if (copiedNodesMap.TryGetValue(guid, out var node))
{
group.InnerNodeGUIDs.Add(node.GUID);
}
}
Model.AddGroup(group);
}
foreach (var edge in data.copiedEdges)
{
//edge.Enable(Model);
copiedNodesMap.TryGetValue(edge.InputNodeGUID, out var inputNode);
copiedNodesMap.TryGetValue(edge.OutputNodeGUID, out var outputNode);
inputNode = inputNode == null ? Model.Nodes[edge.InputNodeGUID] : Model.Nodes[inputNode.GUID];
outputNode = outputNode == null ? Model.Nodes[edge.OutputNodeGUID] : Model.Nodes[outputNode.GUID];
if (inputNode == null || outputNode == null)
{
continue;
}
inputNode.TryGetPort(edge.InputFieldName, out NodePort inputPort);
outputNode.TryGetPort(edge.OutputFieldName, out NodePort outputPort);
if (!inputPort.Multiple && inputPort.IsConnected)
{
continue;
}
if (!outputPort.Multiple && outputPort.IsConnected)
{
continue;
}
if (NodeViews.TryGetValue(inputNode.GUID, out BaseNodeView inputNodeView) &&
NodeViews.TryGetValue(outputNode.GUID, out BaseNodeView outputNodeView))
{
Model.Connect(inputNodeView.Model.Ports[edge.InputFieldName], outputNodeView.Model.Ports[edge.OutputFieldName]);
}
}
SetDirty();
}
public Type GetViewType(INode node)
{
var kv = NodeViews.FirstOrDefault(d => node.Features[0].Equals(d.Key));
return(kv.Value ?? typeof(Views.NodeViews.BasicNodeView));
}
