public void Process(LinkManager linkManager, INodeOutput outCom)
{
if (linkManager.RemoveLinkByBegin(outCom.ID))
{
Logger.Info(outCom.GetType().Name + " is SingleConncect");
}
}
bool ProcessConncectTypes(INodeInput inCom, INodeOutput outCom)
{
ConnectTypes connectTypes;
Type inComType = inCom.GetType();
Type outComType = outCom.GetType();
connectTypes = (ConnectTypes)Attribute.GetCustomAttribute(inComType, typeof(ConnectTypes));
if (connectTypes != null)
{
if (connectTypes.Contains(outComType) == false)
{
Logger.Info(inCom.Name + " Can't Connect Type: " + outCom.Name);
return(false);
}
}
connectTypes = (ConnectTypes)Attribute.GetCustomAttribute(outComType, typeof(ConnectTypes));
if (connectTypes != null)
{
if (connectTypes.Contains(inComType) == false)
{
Logger.Info(outComType.Name + " Can't Connect Type: " + inComType.Name);
return(false);
}
}
return(true);
}
public int AddComponet(INodeOutput component)
{
int id = AddComponet((INodeComponent)component);
AddOutComponet(id, component);
return(id);
}
public int AddComponet(INodeOutput component)
{
int id = m_NodeGraph.ngNodeComponentManager.AddComponet(component);
FillComponent(id, component);
m_RightComponents.Add(id, component);
return(id);
}
void ProcessSingleConncect(INodeOutput outCom)
{
SingleConnect singleConnect = (SingleConnect)Attribute.GetCustomAttribute(outCom.GetType(), typeof(SingleConnect));
if (singleConnect != null)
{
singleConnect.Process(m_NodeGraph.ngLinkManager, outCom);
}
}
public bool ConncectValueTypeProc(INodeInput inCom, INodeOutput outCom)
{
Type inComType = inCom.GetType();
ConnectValueType connectValueType = (ConnectValueType)Attribute.GetCustomAttribute(inComType, typeof(ConnectValueType));
if (connectValueType != null)
{
return(connectValueType.Process(m_NodeGraph, inCom, outCom));
}
return(true);
}
public void TryAddConvertNdoe(INodeGraph nodeGraph, INodeInput inCom, INodeOutput outCom, Type outValueType)
{
foreach (var nodePair in ConvertNdoeDict)
{
AConvertNode aConvert = (AConvertNode)nodePair.Value;
if (aConvert.ConvertType.Equals(AcceptType))
{
IConvertNode convertNode = (IConvertNode)ClassTools.CallConstructor(nodePair.Key, nodeGraph);
AddNodeBetween(nodeGraph, inCom.ParentNode, outCom.ParentNode, convertNode);
convertNode.InputConnect(outCom);
convertNode.OutputConnect(inCom);
}
}
}
public bool Process(INodeGraph nodeGraph, INodeInput inCom, INodeOutput outCom)
{
Type outValueType = (Type)outCom.Request(ERequest.InstanceType);
if (outValueType.Equals(AcceptType))
{
return(true);
}
else
{
Logger.Info(outValueType.Name + " need convert to: " + AcceptType.Name);
TryAddConvertNdoe(nodeGraph, inCom, outCom, outValueType);
return(false);
}
}
public bool ComCanConnect(INodeInput inCom, INodeOutput outCom)
{
if (ProcessConncectTypes(inCom, outCom) == false)
{
return(false);
}
if (ConncectValueTypeProc(inCom, outCom) == false)
{
return(false);
}
ProcessSingleConncect(inCom);
ProcessSingleConncect(outCom);
return(true);
}
public void TryCreateLink(INodeOutput startNodeCom, INodeInput endNodeCom) => NotifyLinkCreatedEvent(startNodeCom.ID, endNodeCom.ID);
public override bool InputConnect(INodeOutput outCom)
{
NodeGraph.ngLinkManager.TryCreateLink(outCom.ID, m_ObjectIC.ID);
return(NodeGraph.ngLinkManager.IsConnect(outCom.ID, m_ObjectIC.ID));
}
public abstract bool InputConnect(INodeOutput outCom);
//Event
public virtual bool TryConnectBy(INodeOutput component)
{
return(false);
}
void AddOutComponet(int id, INodeOutput outCom) => g_OutComponents.Add(id, outCom);
//Event
public override bool TryConnectBy(INodeOutput component)
{
m_Connect = component;
return(true);
}
