private static InputPortConfigInfo ConvertToInputPortInfo(InputPortEditorView inputPort)
{
InputPortConfigInfo inputPortConfigInfo = new InputPortConfigInfo();
InputPortReflectionInfo inputPortReflectionInfo = inputPort.inputPortReflectionInfo;
inputPortConfigInfo.portName = inputPortReflectionInfo.inputPortAttribute.portName;
if (inputPort.connectedPortList.Count > 0)
{
inputPortConfigInfo.targetNodeId = inputPort.connectedPortList[0].NodeView.NodeId;
OutputPortEditorView outputPortView = inputPort.connectedPortList[0] as OutputPortEditorView;
if (outputPortView == null)
{
Debug.LogErrorFormat("节点{0}的input端口{1} 连接的接口类型不是OutputPortEditorView", inputPort.NodeView.NodeId,
inputPort.portId);
return(null);
}
inputPortConfigInfo.targetPortName = outputPortView.outputPortReflectionInfo.PortName;
}
else
{
inputPortConfigInfo.targetNodeId = -1;
inputPortConfigInfo.targetPortName = string.Empty;
inputPortConfigInfo.nodeVariableGenericTypeName = inputPortReflectionInfo.inputValueType.FullName;
inputPortConfigInfo.nodeVariableValue = inputPortReflectionInfo.GetNodeVariableValueString();
}
return(inputPortConfigInfo);
}
/// <summary>
/// 检查input port和output port连线的合法性
/// </summary>
public void CheckIOPortConnectionValidate()
{
for (int i = 0; i < inputPortViewList.Count; i++)
{
InputPortEditorView inputPortView = inputPortViewList[i];
if (inputPortView.connectedPortList.Count == 1)
{
if (!ConnectionLineView.CheckPortsCanLine(inputPortView, inputPortView.connectedPortList[0]))
{
graph.data.FindConnectionByPortsAndRemoveIt(inputPortView, inputPortView.connectedPortList[0]);
}
}
}
for (int i = 0; i < outputPortViewList.Count; i++)
{
OutputPortEditorView outputPortView = outputPortViewList[i];
for (int j = 0; j < outputPortView.connectedPortList.Count; j++)
{
InputPortEditorView connectedInputPortView = outputPortView.connectedPortList[j] as InputPortEditorView;
if (connectedInputPortView == null)
{
continue;
}
if (!ConnectionLineView.CheckPortsCanLine(outputPortView, connectedInputPortView))
{
graph.data.FindConnectionByPortsAndRemoveIt(outputPortView, connectedInputPortView);
}
}
}
}
/// <summary>
/// 检查两个端口是否可以连接
/// </summary>
/// <param name="portA"></param>
/// <param name="portB"></param>
/// <returns></returns>
public static bool CheckPortsCanLine(PortEditorView portA, PortEditorView portB)
{
if (portA == null || portB == null)
{
return(false);
}
if (portA.FlowType == portB.FlowType)
{
return(false);
}
if (portA.NodeView == portB.NodeView)
{
return(false);
}
PortEditorView flowOutPortView = portA.FlowType == FlowType.Out ? portA : portB;
PortEditorView flowInPortView = portA.FlowType == FlowType.In ? portA : portB;
//两边接口是流出和流入
if (flowOutPortView is FlowOutPortEditorView && flowInPortView is FlowInPortEditorView)
{
return(true);
}
//两边接口是Output和Input
OutputPortEditorView outputPortView = flowOutPortView as OutputPortEditorView;
InputPortEditorView inputPortView = flowInPortView as InputPortEditorView;
if (outputPortView == null || inputPortView == null)
{
Debug.LogError("端口连接类型错误");
return(false);
}
if (outputPortView.PortValueType != inputPortView.PortValueType)
{
return(false);
}
//存取技能变量的端口，都不允许连接
if (inputPortView.inputPortReflectionInfo.inputValueType == typeof(VariableWrapper))
{
return(false);
}
return(true);
}
/// <summary>
/// 递归获取该节点创建sequence时需要包含的所有节点id
/// 遇到CreateSequenceNode则停止往右探索
/// </summary>
/// <returns></returns>
public void GetSequenceNodesIdsRecursive(ref List <int> rightSideNodeIdList)
{
if (rightSideNodeIdList == null)
{
rightSideNodeIdList = new List <int>();
}
if (flowOutPortViews != null)
{
for (int i = 0; i < flowOutPortViews.Length; i++)
{
List <PortEditorView> connectionPortList = flowOutPortViews[i].connectedPortList;
for (int j = 0; j < connectionPortList.Count; j++)
{
NodeEditorView targetNode = connectionPortList[j].NodeView;
int nodeId = targetNode.NodeId;
if (!rightSideNodeIdList.Contains(nodeId))
{
rightSideNodeIdList.Add(nodeId);
if (!targetNode.ReflectionInfo.IsCreateSequenceNode)
{
targetNode.GetSequenceNodesIdsRecursive(ref rightSideNodeIdList);
}
}
}
}
}
for (int i = 0; i < outputPortViewList.Count; i++)
{
OutputPortEditorView outputPort = outputPortViewList[i];
List <PortEditorView> connectionPortList = outputPort.connectedPortList;
for (int j = 0; j < connectionPortList.Count; j++)
{
NodeEditorView targetNode = connectionPortList[j].NodeView;
int nodeId = targetNode.NodeId;
if (!rightSideNodeIdList.Contains(nodeId))
{
rightSideNodeIdList.Add(nodeId);
if (!targetNode.ReflectionInfo.IsCreateSequenceNode)
{
targetNode.GetSequenceNodesIdsRecursive(ref rightSideNodeIdList);
}
}
}
}
}
/// <summary>
/// 当节点对应的是<see cref="FlatNode.Runtime.GetVariableNode"/> 或者 <see cref="FlatNode.Runtime.SetVariableNode"/> 时
/// 他们接口的类型需要显示为对应类型。
/// 还要重新计算节点Rect的大小
/// </summary>
/// <param name="variableType"></param>
/// <param name="needRecheckConnection"></param>
public void UpdateGraphVariableNodeIOPortType(Type variableType, bool needRecheckConnection)
{
if (ReflectionInfo.Type == typeof(GetVariableNode))
{
//第一个input port是选择要读取哪一个变量
InputPortEditorView inputPortView = inputPortViewList[0];
inputPortView.overridePortType = variableType;
//第一个output port是要输出选择的变量
OutputPortEditorView outputPortView = outputPortViewList[0];
outputPortView.overridePortType = variableType;
CalculateNodeSize();
if (needRecheckConnection)
{
CheckIOPortConnectionValidate();
}
}
else if (ReflectionInfo.Type == typeof(SetVariableNode))
{
//第一个input port是选择要存储到哪个变量
InputPortEditorView setVariableInputPort = inputPortViewList[0];
setVariableInputPort.overridePortType = variableType;
//第二个input port是接收要存储的值
InputPortEditorView valueVariableInputPort = inputPortViewList[1];
valueVariableInputPort.overridePortType = variableType;
//该节点没有output port
CalculateNodeSize();
if (needRecheckConnection)
{
CheckIOPortConnectionValidate();
}
}
}
private static void UpdateNodeViewData(NodeConfigInfo nodeConfigInfo, NodeEditorView nodeView, GraphEditorData data)
{
//flow in port--处理流出节点的时候顺便就处理了
//flow out port
for (int i = 0; i < nodeConfigInfo.flowOutPortInfoList.Count; i++)
{
FlowOutPortConfigInfo flowOutPortConfigInfo = nodeConfigInfo.flowOutPortInfoList[i];
FlowOutPortEditorView flowOutPortView =
GetFlowOutPortViewByPortName(nodeView.flowOutPortViews, flowOutPortConfigInfo.flowOutPortName);
if (flowOutPortView == null)
{
Debug.LogFormat("节点{0}中找不到流出端口 <{1}> 了,该端口的连接被忽略", nodeView.ReflectionInfo.Type,
flowOutPortConfigInfo.flowOutPortName);
continue;
}
for (int j = 0; j < flowOutPortConfigInfo.targetNodeList.Count; j++)
{
int targetNodeId = flowOutPortConfigInfo.targetNodeList[j];
NodeEditorView targetNodeView = data.GetNode(targetNodeId);
if (targetNodeView == null)
{
Debug.LogErrorFormat("无法找到节点{0}，可能是配置损坏/更改了类名...", targetNodeId);
continue;
}
if (targetNodeView.flowInPortView == null)
{
Debug.LogErrorFormat("节点类型{0}没有流入节点，是否节点性质发生了改变?", nodeView.ReflectionInfo.Type.FullName);
continue;
}
ConnectionLineView connectionLineView =
new ConnectionLineView(flowOutPortView, targetNodeView.flowInPortView, data);
data.connectionLineList.Add(connectionLineView);
}
}
//output port -- 不用配置
//input port
for (int i = 0; i < nodeConfigInfo.inputPortInfoList.Count; i++)
{
InputPortConfigInfo inputPortConfigInfo = nodeConfigInfo.inputPortInfoList[i];
InputPortEditorView inputPortView =
GetInputPortViewByPortName(nodeView.inputPortViewList, inputPortConfigInfo.portName);
if (inputPortView == null)
{
Debug.LogFormat("节点{0}中无法找到接口名字为 <{1}> 的NodeInputVariable Field，该接口配置被跳过",
nodeView.ReflectionInfo.Type.FullName, inputPortConfigInfo.portName);
continue;
}
//没有连接到其他节点的情况
if (string.IsNullOrEmpty(inputPortConfigInfo.targetPortName))
{
//设置默认值
Type valueType = Type.GetType(inputPortConfigInfo.nodeVariableGenericTypeName);
if (valueType == null)
{
valueType = Type.GetType(inputPortConfigInfo.nodeVariableGenericTypeName + ",UnityEngine");
if (valueType == null)
{
valueType = Type.GetType(inputPortConfigInfo.nodeVariableGenericTypeName + ",Assembly-CSharp");
}
}
if (valueType == null)
{
Debug.LogErrorFormat("工程中找不到类型： {0}", inputPortConfigInfo.nodeVariableGenericTypeName);
continue;
}
SetNodeInputVariableValue(inputPortView.inputPortReflectionInfo, valueType,
inputPortConfigInfo.nodeVariableValue, nodeView);
}
//连接到其他节点的情况
else
{
NodeEditorView connectedToNodeView = data.GetNode(inputPortConfigInfo.targetNodeId);
if (connectedToNodeView == null)
{
Debug.LogErrorFormat("节点 {0} 的input接口 {1} 找不到连接的节点{2}", nodeView.NodeId, inputPortConfigInfo.portName,
inputPortConfigInfo.targetNodeId);
continue;
}
OutputPortEditorView connectedToOutputPortView =
GetOutputPortViewByPortName(connectedToNodeView.outputPortViewList, inputPortConfigInfo.targetPortName);
if (connectedToOutputPortView == null)
{
Debug.LogFormat("找不到节点{0}中 接口名字为 <{1}> 的output接口，该接口的连接被跳过", connectedToNodeView.NodeId,
inputPortConfigInfo.targetPortName);
continue;
}
ConnectionLineView connectionLineView =
new ConnectionLineView(inputPortView, connectedToOutputPortView, data);
data.connectionLineList.Add(connectionLineView);
}
}
}
public NodeEditorView(Vector2 graphPosition, GraphEditorWindow graph, int nodeId, NodeReflectionInfo reflectionInfo)
{
this.graph = graph;
this.NodeId = nodeId;
this.ReflectionInfo = reflectionInfo;
PositionInGraph = graphPosition;
PositionInWindow = graph.GraphPositionToWindowPosition(graphPosition);
viewRect = new Rect(Vector2.zero, new Vector2(200, 400));
allPortList = new List <PortEditorView>();
inputPortViewList = new List <InputPortEditorView>();
outputPortViewList = new List <OutputPortEditorView>();
leftPortLayoutHelper = new PortLayoutHelper();
rightPortLayoutHelper = new PortLayoutHelper();
if (reflectionInfo.HasFlowInPort)
{
flowInPortView = new FlowInPortEditorView(this);
flowInPortView.portId = 0;
allPortList.Add(flowInPortView);
}
if (reflectionInfo.flowOutPortDefineAttributes.Length > 0)
{
flowOutPortViews = new FlowOutPortEditorView[reflectionInfo.flowOutPortDefineAttributes.Length];
for (int i = 0; i < flowOutPortViews.Length; i++)
{
flowOutPortViews[i] = new FlowOutPortEditorView(this, reflectionInfo.flowOutPortDefineAttributes[i]);
flowOutPortViews[i].portId = i;
allPortList.Add(flowOutPortViews[i]);
}
}
else
{
flowOutPortViews = new FlowOutPortEditorView[0];
}
List <InputPortReflectionInfo> inputPortReflectionInfos = reflectionInfo.inputPortInfoList;
for (int i = 0; i < inputPortReflectionInfos.Count; i++)
{
InputPortReflectionInfo inputPortReflectionInfo = inputPortReflectionInfos[i];
InputPortEditorView inputPortView = new InputPortEditorView(this, inputPortReflectionInfo);
inputPortView.portId = i;
inputPortViewList.Add(inputPortView);
allPortList.Add(inputPortView);
}
List <OutputPortReflectionInfo> outputPortReflectionInfos = reflectionInfo.outputPortInfoList;
for (int i = 0; i < outputPortReflectionInfos.Count; i++)
{
OutputPortReflectionInfo outputPortReflectionInfo = outputPortReflectionInfos[i];
OutputPortEditorView outputPortView = new OutputPortEditorView(this, outputPortReflectionInfo, i);
outputPortView.portId = i;
outputPortViewList.Add(outputPortView);
allPortList.Add(outputPortView);
}
CalculateNodeSize();
}
public void DrawNodeGUI()
{
if (graph == null)
{
return;
}
PositionInWindow = graph.GraphPositionToWindowPosition(PositionInGraph);
viewRect.center = PositionInWindow;
if (isSelected)
{
Rect highLightRect = new Rect(viewRect);
highLightRect.position = highLightRect.position - Vector2.one * 2f;
highLightRect.max = highLightRect.max + Vector2.one * 4f;
GUI.Box(highLightRect, "", Utility.GetGuiStyle("Highlight"));
}
//draw back ground
if (ReflectionInfo.IsEntranceNode)
{
GUI.Box(viewRect, "", Utility.GetGuiStyle("EntranceNode"));
}
if (ReflectionInfo.Type.IsSubclassOf(typeof(GraphVariableNodeBase)))
{
GUI.Box(viewRect, "", Utility.GetGuiStyle("NodeCyan"));
}
else
{
GUI.Box(viewRect, "", Utility.GetGuiStyle("NodeBg"));
}
//draw node name
GUI.Label(NodeNameRect, string.Format("({0}){1}", NodeId, ReflectionInfo.NodeName), Utility.GetGuiStyle("NodeName"));
leftPortLayoutHelper.SetPosition(new Vector2(viewRect.x, viewRect.y + NodeNameRect.height + PortAreaPadding));
rightPortLayoutHelper.SetPosition(new Vector2(viewRect.x, viewRect.y + NodeNameRect.height + PortAreaPadding));
if (flowInPortView != null)
{
flowInPortView.portViewRect = leftPortLayoutHelper.GetRect();
}
for (int i = 0; i < inputPortViewList.Count; i++)
{
InputPortEditorView inputPortView = inputPortViewList[i];
inputPortView.portViewRect = leftPortLayoutHelper.GetRect();
}
if (flowOutPortViews.Length > 0)
{
for (int i = 0; i < flowOutPortViews.Length; i++)
{
FlowOutPortEditorView flowoutPortView = flowOutPortViews[i];
flowoutPortView.portViewRect = rightPortLayoutHelper.GetRect();
}
}
for (int i = 0; i < outputPortViewList.Count; i++)
{
OutputPortEditorView outputPortView = outputPortViewList[i];
outputPortView.portViewRect = rightPortLayoutHelper.GetRect();
}
for (int i = 0; i < allPortList.Count; i++)
{
PortEditorView portView = allPortList[i];
portView.Draw();
}
}
