public static void InitNodePinTypes(CodeGenerateSystem.Base.ConstructionParams smParam)
{
var splits = smParam.ConstructParam.Split(',');
var valueType = splits[0];
CollectLinkPinInfo(smParam, "OutLink", LinkPinControl.GetLinkTypeFromTypeString(valueType), enBezierType.Right, enLinkOpType.Start, true);
}
public override bool CanLink(LinkPinControl linkPin, LinkPinControl pinInfo)
{
if (mOrigionType == typeof(string))
{
return(pinInfo.LinkType == enLinkType.String);
}
else if (mOrigionType != typeof(string) && mOrigionType.IsValueType && mOrigionType.IsPrimitive)
{
return((pinInfo.LinkType & enLinkType.NumbericalValue) == pinInfo.LinkType);
}
var type = EngineNS.Rtti.RttiHelper.GetTypeFromTypeFullName(pinInfo.ClassType);
if (type == null)
{
return(false);
}
if (type == mOrigionType)
{
return(true);
}
if (type.IsSubclassOf(mOrigionType))
{
return(true);
}
return(true);
}
void InitializeLinkControl(LASPChildBlendTimeNodeControlConstructionParams csParam)
{
mLinkInHandle = ValueIn;
mLinkInHandle.OnAddLinkInfo += LinkInHandle_OnAddLinkInfo;
mLinkInHandle.OnDelLinkInfo += LinkInHandle_OnDelLinkInfo;
AddLinkPinInfo("LASPBlendTimeLinkInHandle", mLinkInHandle, null);
}
public override CodeExpression GCode_CodeDom_GetValue(LinkPinControl element, GenerateCodeContext_Method context, GenerateCodeContext_PreNode preNodeContext = null)
{
var param = CSParam as ExpandNodeChildConstructionParams;
var expNode = ParentNode as ExpandNode;
var tagExp = expNode.GCode_CodeDom_GetValue(null, context, null);
return(new CodePropertyReferenceExpression(tagExp, param.ParamName));
}
public override CodeExpression GCode_CodeDom_GetValue(LinkPinControl element, GenerateCodeContext_Method context, GenerateCodeContext_PreNode preNodeContext = null)
{
var param = CSParam as MethodInvoke_DelegateControlConstructionParams;
var lambdaExp = new CodeGenerateSystem.CodeDom.CodeLambdaExpression();
lambdaExp.LambdaFieldName = "lambda_" + MethodName;
var method = param.ParamInfo.ParameterType.GetMethod("Invoke");
var methodInvokeExp = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression();
methodInvokeExp.Method = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), MethodName);
foreach (var methodParam in method.GetParameters())
{
var lambdaParam = new CodeGenerateSystem.CodeDom.CodeLambdaExpression.LambdaParam();
if (methodParam.IsOut)
{
lambdaParam.Dir = FieldDirection.Out;
lambdaParam.Name = "__" + methodParam.Name;
lambdaExp.LambdaParams.Add(lambdaParam);
}
else if (methodParam.ParameterType.IsByRef)
{
lambdaParam.Dir = FieldDirection.Ref;
lambdaParam.Name = "__" + methodParam.Name;
lambdaExp.LambdaParams.Add(lambdaParam);
}
else
{
lambdaParam.Dir = FieldDirection.In;
lambdaParam.Name = "__" + methodParam.Name;
lambdaExp.LambdaParams.Add(lambdaParam);
}
methodInvokeExp.Parameters.Add(new CodeDirectionExpression(lambdaParam.Dir, new CodeVariableReferenceExpression(lambdaParam.Name)));
}
foreach (var child in mChildNodes)
{
// 获取连线参数的数值
var paramNode = child as MethodInvokeParameterControl;
var linkOI = paramNode.ParamPin;
var fromNode = linkOI.GetLinkedObject(0, true);
var exp = fromNode.GCode_CodeDom_GetValue(linkOI.GetLinkedPinControl(0, true), context);
methodInvokeExp.Parameters.Add(exp);
}
lambdaExp.MethodInvoke = methodInvokeExp;
if (method.ReturnType != typeof(void))
{
lambdaExp.NeedReturn = true;
}
return(lambdaExp);
}
public override CodeExpression GCode_CodeDom_GetValue(LinkPinControl element, GenerateCodeContext_Method context, GenerateCodeContext_PreNode preNodeContext = null)
{
if (element == null || element == mCtrlTarget || element == mCtrlTargetOut)
{
return(mCtrlTarget.GetLinkedObject(0).GCode_CodeDom_GetValue(mCtrlTarget.GetLinkedPinControl(0), context, null));
}
else
{
throw new InvalidOperationException();
}
}
public override string GCode_GetTypeString(LinkPinControl element, GenerateCodeContext_Method context)
{
if (element == null || element == mCountOutPin)
{
return("System.Int32");
}
else
{
throw new InvalidOperationException();
}
}
public override bool CanLink(LinkPinControl linkPin, LinkPinControl pinInfo)
{
if ((pinInfo.LinkType & enLinkType.Enumerable) != enLinkType.Enumerable)
{
return(false);
}
// todo: 类型判断
//pinInfo.ClassType
return(true);
}
public override CodeExpression GCode_CodeDom_GetValue(LinkPinControl element, GenerateCodeContext_Method context, GenerateCodeContext_PreNode preNodeContext = null)
{
if (element == null || element == mCountOutPin)
{
var arrayValue = mArrayInPin.GetLinkedObject(0, true).GCode_CodeDom_GetValue(mArrayInPin.GetLinkedPinControl(0, true), context);
return(new CodePropertyReferenceExpression(arrayValue, "Count"));
}
else
{
throw new InvalidOperationException();
}
}
public override bool CanLink(LinkPinControl selfLinkPin, LinkPinControl otherLinkPin)
{
if (selfLinkPin == mActiveLinkHandle)
{
var type = otherLinkPin.HostNodeControl.GCode_GetType(otherLinkPin, null);
if (type.IsEnum)
{
return(true);
}
return(false);
}
return(true);
}
public override void RefreshFromLink(LinkPinControl pin, int linkIndex)
{
if (OrigionType == typeof(object))
{
if (pin == mArrayOutPin)
{
OrigionType = GetElementTypeFromArrayLink();
}
else
{
OrigionType = GetElementTypeFromElementChildren();
}
}
}
protected override void EndLink(LinkPinControl linkObj)
{
bool alreadyLink = false;
var pinInfo = GetLinkPinInfo("AnimStateLinkHandle");
if (HostNodesContainer.StartLinkObj == linkObj)
{
//base.EndLink(null);
if (HostNodesContainer.PreviewLinkCurve != null)
{
HostNodesContainer.PreviewLinkCurve.Visibility = System.Windows.Visibility.Hidden;
}
return;
}
var count = pinInfo.GetLinkInfosCount();
for (int index = 0; index < count; ++index)
{
AnimStateLinkInfoForUndoRedo undoRedoLinkInfo = new AnimStateLinkInfoForUndoRedo();
var linkInfo = pinInfo.GetLinkInfo(index);
if (linkInfo.m_linkFromObjectInfo == HostNodesContainer.StartLinkObj && linkInfo.m_linkToObjectInfo == linkObj)
{
alreadyLink = true;
undoRedoLinkInfo.linkInfo = linkInfo as AnimStateLinkInfo;
NodesContainer.TransitionStaeBaseNodeForUndoRedo transCtrl = new NodesContainer.TransitionStaeBaseNodeForUndoRedo();
var redoAction = new Action <Object>((obj) =>
{
transCtrl.TransitionStateNode = undoRedoLinkInfo.linkInfo.AddTransition();
});
redoAction.Invoke(null);
EditorCommon.UndoRedo.UndoRedoManager.Instance.AddCommand(HostNodesContainer.HostControl.UndoRedoKey, null, redoAction, null,
(obj) =>
{
undoRedoLinkInfo.linkInfo.RemoveTransition(transCtrl.TransitionStateNode);
}, "Create StateTransition");
}
if (HostNodesContainer.PreviewLinkCurve != null)
{
HostNodesContainer.PreviewLinkCurve.Visibility = System.Windows.Visibility.Hidden;
}
//base.EndLink(null,false);
}
if (!alreadyLink)
{
base.EndLink(linkObj);
}
}
void InitializeLinkControl(LASelectPoseByIntControlConstructionParams csParam)
{
mActiveLinkHandle = ActiveValueHandle;
mOutLinkHandle = OutPoseHandle;
mOutLinkHandle.MultiLink = false;
mActiveLinkHandle.NameStringVisible = Visibility.Visible;
mActiveLinkHandle.NameString = "ActiveValue";
mActiveLinkHandle.OnAddLinkInfo += ActiveValueLinkHandle_OnAddLinkInfo;
mActiveLinkHandle.OnDelLinkInfo += ActiveValueLinkHandle_OnDelLinkInfo;
AddLinkPinInfo("ActiveValueHandle", mActiveLinkHandle, null);
AddLinkPinInfo("OutLinkHandle", mOutLinkHandle, null);
}
public override void RefreshFromLink(LinkPinControl pin, int linkIndex)
{
if (ElementType == typeof(object))
{
if (pin == mArrayInPin)
{
var listType = pin.GetLinkedObject(0, true).GCode_GetType(pin.GetLinkedPinControl(0, true), null);
ElementType = listType.GetGenericArguments()[0];
}
else if (pin == mValueInPin)
{
ElementType = pin.GetLinkedObject(0, true).GCode_GetType(pin.GetLinkedPinControl(0, true), null);
}
else
{
throw new InvalidOperationException();
}
}
}
void InitializeLinkControl(LASelectPoseByBoolControlConstructionParams csParam)
{
mActiveLinkHandle = ActiveValueHandle;
mTrueLinkHandle = TruePoseHandle;
mFalseLinkHandle = FalsePoseHandle;
mTrueBlendValueLinkHandle = TrueBlendValueHandle;
mFalseBlendValueLinkHandle = FalseBlendValueHandle;
mOutLinkHandle = OutPoseHandle;
mTrueLinkHandle.MultiLink = false;
mFalseBlendValueLinkHandle.MultiLink = false;
mTrueBlendValueLinkHandle.MultiLink = false;
mFalseBlendValueLinkHandle.MultiLink = false;
mOutLinkHandle.MultiLink = false;
mActiveLinkHandle.NameStringVisible = Visibility.Visible;
mActiveLinkHandle.NameString = "ActiveValue";
mActiveLinkHandle.OnAddLinkInfo += BoolValueLinkHandle_OnAddLinkInfo;
mActiveLinkHandle.OnDelLinkInfo += BoolValueLinkHandle_OnDelLinkInfo;
mTrueLinkHandle.NameStringVisible = Visibility.Visible;
mTrueLinkHandle.NameString = "TruePose";
mFalseLinkHandle.NameStringVisible = Visibility.Visible;
mFalseLinkHandle.NameString = "FalsePose";
mTrueBlendValueLinkHandle.NameStringVisible = Visibility.Visible;
mTrueBlendValueLinkHandle.NameString = "TrueBlendTime";
TrueBlendTextBlock.Visibility = Visibility.Visible;
mTrueBlendValueLinkHandle.OnAddLinkInfo += TrueBlendValueLinkHandle_OnAddLinkInfo;
mTrueBlendValueLinkHandle.OnDelLinkInfo += TrueBlendValueLinkHandle_OnDelLinkInfo;
mFalseBlendValueLinkHandle.NameStringVisible = Visibility.Visible;
mFalseBlendValueLinkHandle.NameString = "FalseBlendTime";
FalseBlendTextBlock.Visibility = Visibility.Visible;
mFalseBlendValueLinkHandle.OnAddLinkInfo += FalseBlendValueLinkHandle_OnAddLinkInfo;
mFalseBlendValueLinkHandle.OnDelLinkInfo += FalseBlendValueLinkHandle_OnDelLinkInfo;
AddLinkPinInfo("ActiveValueHandle", mActiveLinkHandle, null);
AddLinkPinInfo("TrueLinkHandle", mTrueLinkHandle, null);
AddLinkPinInfo("FalseLinkHandle", mFalseLinkHandle, null);
AddLinkPinInfo("TrueBlendValueLinkHandle", mTrueBlendValueLinkHandle, null);
AddLinkPinInfo("FalseBlendValueLinkHandle", mFalseBlendValueLinkHandle, null);
AddLinkPinInfo("OutLinkHandle", mOutLinkHandle, null);
}
public override Type GCode_GetType(LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context)
{
if (element == null || element == mCountOutPin)
{
return(typeof(Int32));
}
else if (element == mArrayInPin)
{
if (mArrayInPin.HasLink)
{
return(mArrayInPin.GetLinkedObject(0).GCode_GetType(mArrayInPin.GetLinkedPinControl(0), context));
}
return(typeof(object));
}
else
{
throw new InvalidOperationException();
}
}
void _OnNodeListItemSelected(NodeListAttributeClass item)
{
IsOpenContextMenu = false;
var node = CreateNodeFromNodeListItem(item, mContextMenuOpenMousePos);
if (node != null && item.FilterData.StartLinkObj != null)
{
var nodePins = node.GetLinkPinInfos();
LinkPinControl nodeLink = null;
foreach (var pin in nodePins)
{
if (pin.Visibility != Visibility.Visible)
{
continue;
}
if (CodeGenerateSystem.Base.LinkInfo.CanLinkWith(item.FilterData.StartLinkObj, pin))
{
nodeLink = pin;
break;
}
}
if (nodeLink != null)
{
if (nodeLink.Visibility == Visibility.Visible)
{
LinkPinControl startLink, endLink;
if (item.FilterData.StartLinkObj.LinkOpType == enLinkOpType.Start)
{
startLink = item.FilterData.StartLinkObj;
endLink = nodeLink;
}
else
{
startLink = nodeLink;
endLink = item.FilterData.StartLinkObj;
}
var linkInfo = LinkInfo.CreateLinkInfo(nodeLink.LinkCurveType, MainDrawCanvas, startLink, endLink);
}
}
}
}
public static bool CanLinkWith2(LinkPinControl startObj, LinkPinControl endObj)
{
if (startObj == endObj)
{
return(false);
}
//if (endObj.LinkInfos.Count > 0)
// return false;
if (startObj.HostNodeControl == endObj.HostNodeControl)
{
return(false);
}
else
{
CheckLinkObject(startObj, endObj);
}
return(true);
}
public override Type GCode_GetType(LinkPinControl element, GenerateCodeContext_Method context)
{
if (element == mCtrlArrayElement)
{
return(ElementType);
}
else if (element == mCtrlArrayIndex)
{
return(typeof(int));
}
else if (element == mCtrlDicKey)
{
return(KeyType);
}
else if (element == mCtrlDicValue)
{
return(ElementType);
}
return(base.GCode_GetType(element, context));
}
public override string GCode_GetTypeString(LinkPinControl element, GenerateCodeContext_Method context)
{
if (element == mCtrlArrayElement)
{
return(EngineNS.Rtti.RttiHelper.GetAppTypeString(ElementType));
}
else if (element == mCtrlArrayIndex)
{
return(EngineNS.Rtti.RttiHelper.GetAppTypeString(typeof(int)));
}
else if (element == mCtrlDicKey)
{
return(EngineNS.Rtti.RttiHelper.GetAppTypeString(KeyType));
}
else if (element == mCtrlDicValue)
{
return(EngineNS.Rtti.RttiHelper.GetAppTypeString(ElementType));
}
return(base.GCode_GetTypeString(element, context));
}
void InitializeLinkControl(LASelectPoseByEnumControlConstructionParams csParam)
{
mActiveLinkHandle = ActiveValueHandle;
mOutLinkHandle = OutPoseHandle;
mOutLinkHandle.MultiLink = false;
mActiveLinkHandle.NameStringVisible = Visibility.Visible;
mActiveLinkHandle.NameString = "ActiveValue";
mActiveLinkHandle.OnAddLinkInfo += ActiveValueLinkHandle_OnAddLinkInfo;
mActiveLinkHandle.OnDelLinkInfo += ActiveValueLinkHandle_OnDelLinkInfo;
AddLinkPinInfo("EnumActiveValueHandle", mActiveLinkHandle, null);
AddLinkPinInfo("OutLinkHandle", mOutLinkHandle, null);
var childPoseNodeCP = new LASPChildPoseLinkNodeControlConstructionParams()
{
IndexValue = "Default",
CSType = CSParam.CSType,
HostNodesContainer = this.HostNodesContainer,
};
mDefaultCtrl = new LASPChildPoseLinkNodeControl(childPoseNodeCP);
AddChildNode(mDefaultCtrl, LinkNodeStackPanel);
var childBlendTimeNodeCP = new LASPChildBlendTimeNodeControlConstructionParams()
{
IndexValue = "Default",
BlendTimeValue = 0.1f,
CSType = CSParam.CSType,
HostNodesContainer = this.HostNodesContainer,
};
mDefaultBlendTimeCtrl = new LASPChildBlendTimeNodeControl(childBlendTimeNodeCP);
mDefaultBlendTimeCtrl.Margin = new Thickness(4, 0, 0, 0);
AddChildNode(mDefaultBlendTimeCtrl, LinkNodeStackPanel);
}
public override bool CanLink(LinkPinControl selfLinkPin, LinkPinControl otherLinkPin)
{
if (selfLinkPin == mCasePin)
{
var switchNode = ParentNode as SwitchNode;
if (!switchNode.SwitchItemPin.HasLink)
{
return(false);
}
if (mOrigionType == typeof(string))
{
return(otherLinkPin.LinkType == enLinkType.String);
}
else if (mOrigionType != typeof(string) && mOrigionType.IsValueType && mOrigionType.IsPrimitive)
{
return((otherLinkPin.LinkType & enLinkType.NumbericalValue) == otherLinkPin.LinkType);
}
var type = EngineNS.Rtti.RttiHelper.GetTypeFromTypeFullName(otherLinkPin.ClassType);
if (type == null)
{
return(false);
}
if (type == mOrigionType)
{
return(true);
}
if (type.IsSubclassOf(mOrigionType))
{
return(true);
}
return(false);
}
return(true);
}
public static void InitNodePinTypes(CodeGenerateSystem.Base.ConstructionParams smParam)
{
CollectLinkPinInfo(smParam, "mAlbedo", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mNormal", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mMetallic", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mRough", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mAbsSpecular", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mTransmit", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mEmissive", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mFuzz", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mIridescence", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mDistortion", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mAlpha", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mAlphaTest", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mVertexOffset", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mSubAlbedo", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mAO", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mMask", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mShadowColor", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mDeepShadow", LinkPinControl.GetLinkTypeFromTypeString("float"), enBezierType.Left, enLinkOpType.End, false);
CollectLinkPinInfo(smParam, "mMoodColor", LinkPinControl.GetLinkTypeFromTypeString("float3"), enBezierType.Left, enLinkOpType.End, false);
}
public static bool CheckLinkObject(LinkPinControl startObj, LinkPinControl endObj)
{
var basenode = endObj.HostNodeControl as StructNodeControl;
if (basenode != null && basenode.CtrlValueLinkHandleDown.LinkInfos.Count > 0)
{
var infos = basenode.CtrlValueLinkHandleDown.LinkInfos;
for (int i = 0; i < infos.Count; i++)
{
if (infos[i].m_linkToObjectInfo.HostNodeControl == startObj.HostNodeControl)
{
return(false);
}
if (CheckLinkObject(startObj, infos[i].m_linkToObjectInfo))
{
return(false);
}
}
}
return(true);
}
protected override void FilterContextMenu(LinkPinControl startLinkObj)
{
mContextMenuOpenMousePos = Mouse.GetPosition(MainDrawCanvas);
ContextMenuNodeList.NodesList.FilterString = "";
if (startLinkObj != null)
{
var data = new ContextMenuFilterData()
{
StartLinkObj = startLinkObj,
CSType = CSType,
HostContainerControl = this,
};
OnFilterContextMenu?.Invoke(ContextMenuNodeList, data);
}
else
{
var data = new ContextMenuFilterData()
{
CSType = CSType,
HostContainerControl = this,
};
OnFilterContextMenu?.Invoke(ContextMenuNodeList, data);
}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var inPoseLinkObj = mInPoseLinkHandle.GetLinkedObject(0, true);
var inPoseLinkElm = mInPoseLinkHandle.GetLinkedPinControl(0, true);
await inPoseLinkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, inPoseLinkElm, context);
}
public override CodeExpression GCode_CodeDom_GetSelfRefrence(LinkPinControl element, GenerateCodeContext_Method context, GenerateCodeContext_PreNode preNodeContext = null)
{
return(new CodeVariableReferenceExpression(ValidName));
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var baseLinkObj = mBaseLinkHandle.GetLinkedObject(0, true);
var baseLinkElm = mBaseLinkHandle.GetLinkedPinControl(0, true);
if (baseLinkObj != null)
{
await baseLinkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, baseLinkElm, context);
}
var additiveLinkObj = mAdditiveLinkHandle.GetLinkedObject(0, true);
var additiveLinkElm = mAdditiveLinkHandle.GetLinkedPinControl(0, true);
if (additiveLinkObj != null)
{
await additiveLinkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, additiveLinkElm, context);
}
Type nodeType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_AdditivePose);
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(nodeType, ValidName, new CodeObjectCreateExpression(new CodeTypeReference(nodeType)));
codeStatementCollection.Add(stateVarDeclaration);
if (baseLinkObj != null)
{
var baseAssign = new CodeAssignStatement();
baseAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "BaseNode");
baseAssign.Right = baseLinkObj.GCode_CodeDom_GetSelfRefrence(null, null);
codeStatementCollection.Add(baseAssign);
}
if (additiveLinkObj != null)
{
var additiveAssign = new CodeAssignStatement();
additiveAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "AdditiveNode");
additiveAssign.Right = additiveLinkObj.GCode_CodeDom_GetSelfRefrence(null, null);
codeStatementCollection.Add(additiveAssign);
}
var valueEvaluateMethod = new CodeMemberMethod();
valueEvaluateMethod.Name = ValidName + "_AlphaEvaluate";
valueEvaluateMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
valueEvaluateMethod.ReturnType = new CodeTypeReference(typeof(float));
var valueEvaluateMethodContex = new GenerateCodeContext_Method(context.ClassContext, valueEvaluateMethod);
CodeExpression alphaValue = await Helper.GetEvaluateValueExpression(codeClass, valueEvaluateMethodContex, valueEvaluateMethod, mAlphaValueLinkHandle, Alpha);
valueEvaluateMethod.Statements.Add(new CodeMethodReturnStatement(alphaValue));
codeClass.Members.Add(valueEvaluateMethod);
var alphaAssign = new CodeAssignStatement();
alphaAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "EvaluateAlpha");
alphaAssign.Right = new CodeVariableReferenceExpression(valueEvaluateMethod.Name);
codeStatementCollection.Add(alphaAssign);
return;
}
protected override void EndLink(LinkPinControl linkObj)
{
return;
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
//subMacross
if (mLinkedNodesContainer != null)
{
foreach (var ctrl in mLinkedNodesContainer.CtrlNodeList)
{
if (ctrl is CodeGenerateSystem.Controls.FinalTransitionResultControl)
{
await ctrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, element, context);
}
}
}
}
