public async System.Threading.Tasks.Task GenerateCachedPose(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
List<string> cachedPoseNames = new List<string>();
foreach (var ctrl in HostNodesContainer.CtrlNodeList)
{
if (ctrl is CachedAnimPoseControl)
{
if (!cachedPoseNames.Contains(ctrl.NodeName))
cachedPoseNames.Add(ctrl.NodeName);
}
}
foreach (var sub in HostNodesContainer.HostControl.SubNodesContainers)
{
foreach (var ctrl in sub.Value.CtrlNodeList)
{
if (ctrl is CachedAnimPoseControl)
{
if (!cachedPoseNames.Contains(ctrl.NodeName))
cachedPoseNames.Add(ctrl.NodeName);
}
}
}
foreach (var cachedPoseName in cachedPoseNames)
{
var createCachedPose = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "CreateCachedAnimPose"), new CodePrimitiveExpression("CachedPose_" + cachedPoseName));
codeStatementCollection.Add(createCachedPose);
}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
Type clipType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_AnimationClip);
var createLAClipMethodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(clipType), "CreateSync"), new CodeExpression[] { new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(EngineNS.RName)), "GetRName", new CodeExpression[] { new CodePrimitiveExpression(FileName.Name) }) });
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(clipType, ValidName, createLAClipMethodInvoke);
codeStatementCollection.Add(stateVarDeclaration);
var info = await EditorCommon.Resources.ResourceInfoManager.Instance.CreateResourceInfoFromFile(FileName.Address + ".rinfo", null);
var animationInfo = info as EditorCommon.ResourceInfos.AnimationClipResourceInfo;
Notifies.Clear();
foreach (var pair in animationInfo.NotifyTrackMap)
{
Notifies.Add(pair.NotifyName);
}
for (int i = 0; i < Notifies.Count; ++i)
{
var notify = Notifies[i];
var validNotifyName = StringRegex.GetValidName(notify);
validNotifyName = "Anim_Notify_" + validNotifyName;
if (hasTheNotifyMethod(codeClass, validNotifyName))
{
var attachNotifyEventExp = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(ValidName), "AttachNotifyEvent"), new CodeExpression[] { new CodePrimitiveExpression(i), new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), validNotifyName) });
//CodeArrayIndexerExpression arrayIndex = new CodeArrayIndexerExpression(new CodeFieldReferenceExpression(animRef, "Notifies"), new CodePrimitiveExpression(i));
//CodeAttachEventStatement attachEvent = new CodeAttachEventStatement(arrayIndex, "OnNotify", new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), validNotifyName));
codeStatementCollection.Add(attachNotifyEventExp);
}
}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
if (!mCtrlValueLinkHandle.HasLink)
{
return;
}
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
var getCachedPose = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "GetCachedAnimPose"), new CodePrimitiveExpression(NodeName));
CodeFieldReferenceExpression poseRef = null;
if (context.AnimAssetTickHostReferenceExpression is CodeThisReferenceExpression)
{
poseRef = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(context.AnimAssetTickHostReferenceExpression, "AnimationPoseProxy"), "Pose");
}
else
{
poseRef = new CodeFieldReferenceExpression(context.AnimAssetTickHostReferenceExpression, "CachedPose");
}
CodeAssignStatement animPoseAssign = new CodeAssignStatement();
animPoseAssign.Left = poseRef;
animPoseAssign.Right = new CodeFieldReferenceExpression(getCachedPose, "AnimationPose");
codeStatementCollection.Add(animPoseAssign);
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var defaultLinkObj = mDefaultCtrl.ValueIn.GetLinkedObject(0, true);
var defaultLinkElm = mDefaultCtrl.ValueIn.GetLinkedPinControl(0, true);
CodeVariableReferenceExpression defaultItem = null;
if (defaultLinkObj != null)
{
await defaultLinkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, defaultLinkElm, context);
defaultItem = await CreateBlendTree_PoseItemForBlend(codeClass, codeStatementCollection, mDefaultCtrl.ValueIn, ValidName + "_" + mDefaultCtrl.IndexValue + "PoseItem", mDefaultBlendTimeCtrl.ValueIn, mDefaultBlendTimeCtrl.BlendTimeValue, context);
}
List <CodeVariableReferenceExpression> mPoseItemList = new List <CodeVariableReferenceExpression>();
for (int i = 0; i < mPins.Count; ++i)
{
if (mPins[i] == mDefaultCtrl)
{
continue;
}
var linkObj = mPins[i].ValueIn.GetLinkedObject(0, true);
var linkElm = mPins[i].ValueIn.GetLinkedPinControl(0, true);
if (linkObj == null)
{
continue;
}
await linkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, linkElm, context);
var item = await CreateBlendTree_PoseItemForBlend(codeClass, codeStatementCollection, mPins[i].ValueIn, ValidName + "_" + mPins[i].IndexValue + "PoseItem", mBlendTimePins[i].ValueIn, mBlendTimePins[i].BlendTimeValue, context);
mPoseItemList.Add(item);
}
Type nodeType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_SelectPoseByInt);
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(nodeType, ValidName, new CodeObjectCreateExpression(new CodeTypeReference(nodeType)));
codeStatementCollection.Add(stateVarDeclaration);
if (defaultItem != null)
{
var addDefaultInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(ValidName), "Add"), new CodeExpression[] { new CodePrimitiveExpression(-1), defaultItem });
codeStatementCollection.Add(addDefaultInvoke);
}
for (int i = 0; i < mPoseItemList.Count; ++i)
{
int index = (int)Enum.Parse(mEnumType, mPins[i].IndexValue);
var addInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(ValidName), "Add"), new CodeExpression[] { new CodePrimitiveExpression(index), mPoseItemList[i] });
codeStatementCollection.Add(addInvoke);
}
var selectMethod = await CreateSelectedMethod(codeClass, ValidName + ValidName + "_ActiveSelectValue", typeof(int), ActiveEnum, mActiveLinkHandle, context);
var selectMethodAssign = new CodeAssignStatement();
selectMethodAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "EvaluateSelectedFunc");
selectMethodAssign.Right = new CodeVariableReferenceExpression(selectMethod.Name);
codeStatementCollection.Add(selectMethodAssign);
return;
}
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);
}
async Task GenerateLAStateMachine(IMacrossOperationContainer linkCtrl, CodeTypeDeclaration macrossClass, CodeGenerateSystem.Base.GenerateCodeContext_Class codeClassContext, LFSMStatesBridge lFSMStatesBridge)
{
var constructLAGraphMethod = lFSMStatesBridge.ConstructLFSMGraphMethod;
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
lFSMStatesBridge.LFSMStateMachineName = "LFSM_StateMachine";
var createStateMachineMethodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "CrteateStateMachine"), new CodeExpression[] { new CodePrimitiveExpression(lFSMStatesBridge.LFSMStateMachineName) });
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(typeof(EngineNS.Bricks.FSM.SFSM.StackBasedFiniteStateMachine), lFSMStatesBridge.LFSMStateMachineName, createStateMachineMethodInvoke);
constructLAGraphMethod.Statements.Add(stateVarDeclaration);
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Class context)
{
if (!mCtrlValueInputHandle.HasLink)
{
return;
}
System.CodeDom.CodeMemberMethod initMethod = null;
foreach (var member in codeClass.Members)
{
if (member is CodeGenerateSystem.CodeDom.CodeMemberMethod)
{
var method = member as CodeGenerateSystem.CodeDom.CodeMemberMethod;
if (method.Name == "Init")
{
initMethod = method;
}
}
}
if (initMethod == null)
{
initMethod = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
initMethod.Name = "Init";
initMethod.Attributes = MemberAttributes.Override | MemberAttributes.Public;
codeClass.Members.Add(initMethod);
}
var linkObj = mCtrlValueInputHandle.GetLinkedObject(0, true);
var linkElm = mCtrlValueInputHandle.GetLinkedPinControl(0, true);
var methodContext = new GenerateCodeContext_Method(context, initMethod);
methodContext.InstanceAnimPoseReferenceExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "AnimationPoseProxy");
methodContext.AnimAssetAnimPoseProxyReferenceExpression = methodContext.InstanceAnimPoseReferenceExpression;
methodContext.AnimAssetTickHostReferenceExpression = new CodeThisReferenceExpression();
await linkObj.GCode_CodeDom_GenerateCode(codeClass, initMethod.Statements, linkElm, methodContext);
var returnExpression = linkObj.GCode_CodeDom_GetSelfRefrence(mCtrlValueInputHandle, methodContext);
var createCachedPose = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "GetCachedAnimPose"), new CodePrimitiveExpression("CachedPose_" + NodeName));
//CodeVariableDeclarationStatement cachedPoseRef = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.Graphics.Mesh.Animation.CGfxAnimationPose)), NodeName);
//CodeAssignStatement cachedPoseAssign = new CodeAssignStatement();
//cachedPoseAssign.Left = cachedPoseRef;
//cachedPoseAssign.Right = createCachedPose;
//initMethod.Statements.Add(cachedPoseAssign);
CodeFieldReferenceExpression animPoseField = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(returnExpression, "AnimationPoseProxy"), "Pose");
CodeAssignStatement animPoseAssign = new CodeAssignStatement();
animPoseAssign.Left = animPoseField;
animPoseAssign.Right = new CodeFieldReferenceExpression(createCachedPose, "CachedAnimationPose");
initMethod.Statements.Add(animPoseAssign);
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
/*
* EngineNS.GamePlay.StateMachine.AnimationStateMachine StateMachine = new EngineNS.GamePlay.StateMachine.AnimationStateMachine("StateMachine");
* StateMachine.AnimationPose = this.AnimationPose;
* this.AddStateMachine(StateMachine);
*/
var validName = StringRegex.GetValidName(NodeName);
//System.CodeDom.CodeVariableDeclarationStatement st = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.GamePlay.StateMachine.AnimationStateMachine)), validName, new CodeObjectCreateExpression(new CodeTypeReference(typeof(EngineNS.GamePlay.StateMachine.AnimationStateMachine)),new CodePrimitiveExpression(validName)));
System.CodeDom.CodeVariableDeclarationStatement st = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.Bricks.Animation.AnimStateMachine.LogicAnimationStateMachine)), validName);
codeStatementCollection.Add(st);
var createStateMachine = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "CreateStateMachine"), new CodePrimitiveExpression(validName));
CodeVariableReferenceExpression stateMachineRef = new CodeVariableReferenceExpression(validName);
CodeAssignStatement stateMachineAssign = new CodeAssignStatement();
stateMachineAssign.Left = stateMachineRef;
stateMachineAssign.Right = createStateMachine;
codeStatementCollection.Add(stateMachineAssign);
CodeFieldReferenceExpression animPoseField = new CodeFieldReferenceExpression(stateMachineRef, "AnimationPoseProxy");
//CodeAssignStatement animPoseAssign = new CodeAssignStatement();
//animPoseAssign.Left = animPoseField;
//animPoseAssign.Right = context.InstanceAnimPoseReferenceExpression;
//codeStatementCollection.Add(animPoseAssign);
//CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "AddTickComponent");
//var methodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(methodRef, new CodeExpression[] { stateMachineRef });
//codeStatementCollection.Add(methodInvoke);
if (mLinkedNodesContainer == null)
{
return;
}
context.AnimStateMachineReferenceExpression = stateMachineRef;
context.StateMachineAnimPoseReferenceExpression = animPoseField;
foreach (var ctrl in mLinkedNodesContainer.CtrlNodeList)
{
if ((ctrl is CodeDomNode.MethodOverride) ||
(ctrl is CodeDomNode.MethodCustom) || ctrl is FinalAnimPoseControl || ctrl is StateEntryControl)
{
await ctrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, element, context);
}
}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var stateMachineRef = context.AnimStateMachineReferenceExpression;
var linkObj = mCtrlValueLinkHandle.GetLinkedObject(0);
await linkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, element, context);
var state = context.FirstStateReferenceExpression;
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(stateMachineRef, "SetCurrentState");
var methodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(methodRef, new CodeExpression[] { state });
codeStatementCollection.Add(methodInvoke);
var stateNode = linkObj as AnimStateControl;
stateNode.ResetRecursionReachedFlag();
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var trueLinkObj = mTrueLinkHandle.GetLinkedObject(0, true);
var trueLinkElm = mTrueLinkHandle.GetLinkedPinControl(0, true);
if (trueLinkObj != null)
{
await trueLinkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, trueLinkElm, context);
}
var falseLinkObj = mFalseLinkHandle.GetLinkedObject(0, true);
var falseLinkElm = mFalseLinkHandle.GetLinkedPinControl(0, true);
if (falseLinkObj != null)
{
await falseLinkObj.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, falseLinkElm, context);
}
Type nodeType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_SelectPoseByInt);
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(nodeType, ValidName, new CodeObjectCreateExpression(new CodeTypeReference(nodeType)));
codeStatementCollection.Add(stateVarDeclaration);
if (trueLinkObj != null)
{
var trueItem = await CreateBlendTree_PoseItemForBlend(codeClass, codeStatementCollection, mTrueLinkHandle, ValidName + "_TruePoseItem", mTrueBlendValueLinkHandle, TrueBlendValue, context);
var addTrueInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(ValidName), "Add"), new CodeExpression[] { new CodePrimitiveExpression(1), trueItem });
codeStatementCollection.Add(addTrueInvoke);
}
if (falseLinkObj != null)
{
var falseItme = await CreateBlendTree_PoseItemForBlend(codeClass, codeStatementCollection, mFalseLinkHandle, ValidName + "_FalsePoseItem", mFalseBlendValueLinkHandle, FalseBlendValue, context);
var addFalseInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(ValidName), "Add"), new CodeExpression[] { new CodePrimitiveExpression(0), falseItme });
codeStatementCollection.Add(addFalseInvoke);
}
var selectMethod = await CreateSelectedMethod(codeClass, ValidName + "_ActiveSelectValue", typeof(int), BoolValue, mActiveLinkHandle, context);
var selectMethodAssign = new CodeAssignStatement();
selectMethodAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "EvaluateSelectedFunc");
selectMethodAssign.Right = new CodeVariableReferenceExpression(selectMethod.Name);
codeStatementCollection.Add(selectMethodAssign);
return;
}
async Task GenerateLAStateMachine(CategoryItem item, IMacrossOperationContainer linkCtrl, CodeTypeDeclaration macrossClass, CodeGenerateSystem.Base.GenerateCodeContext_Class codeClassContext, LAStatesBridge lAStatesBridge)
{
var constructLAGraphMethod = lAStatesBridge.ConstructLAGraphMethod;
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
lAStatesBridge.LAStateMachineName = item.Name;
var createLAStateMachineMethodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "CreateLAStateMachine"), new CodeExpression[] { new CodePrimitiveExpression(lAStatesBridge.LAStateMachineName) });
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(typeof(EngineNS.Bricks.Animation.AnimStateMachine.LogicAnimationStateMachine), lAStatesBridge.LAStateMachineName, createLAStateMachineMethodInvoke);
var layerTypeAssign = new CodeAssignStatement();
layerTypeAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(item.Name), "LayerType");
var layerProp = item.PropertyShowItem as LAAnimLayerCategoryItemPropertys;
layerTypeAssign.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EngineNS.Bricks.Animation.AnimStateMachine.AnimLayerType)), layerProp.LayerType.ToString());
lAStatesBridge.LAStateMachine = new CodeVariableReferenceExpression(item.Name);
constructLAGraphMethod.Statements.Add(stateVarDeclaration);
constructLAGraphMethod.Statements.Add(layerTypeAssign);
}
public async System.Threading.Tasks.Task <CodeMemberMethod> CreateSelectedMethod(CodeTypeDeclaration codeClass, string methodName, Type returnType, object defaultValue, LinkPinControl linkHandle, GenerateCodeContext_Method context)
{
var valueEvaluateMethod = new CodeMemberMethod();
valueEvaluateMethod.Name = methodName;
valueEvaluateMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
valueEvaluateMethod.ReturnType = new CodeTypeReference(returnType);
var valueEvaluateMethodContex = new GenerateCodeContext_Method(context.ClassContext, valueEvaluateMethod);
var value = await Helper.GetEvaluateValueExpression(codeClass, valueEvaluateMethodContex, valueEvaluateMethod, linkHandle, defaultValue);
var vBoolCast = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(EngineNS.vBOOL)), "FromBoolean"), new CodeExpression[] { value });
var vbool = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.vBOOL)), "vBoolValue", vBoolCast);
valueEvaluateMethod.Statements.Add(vbool);
var valueField = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("vBoolValue"), "Value");
valueEvaluateMethod.Statements.Add(new CodeMethodReturnStatement(valueField));
codeClass.Members.Add(valueEvaluateMethod);
return(valueEvaluateMethod);
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var valueEvaluateMethod = new CodeMemberMethod();
valueEvaluateMethod.Name = ValidName + "_InputEvaluate";
valueEvaluateMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
valueEvaluateMethod.ReturnType = new CodeTypeReference(typeof(EngineNS.Vector3));
var valueEvaluateMethodContex = new GenerateCodeContext_Method(context.ClassContext, valueEvaluateMethod);
var tempInputName = "tempInput";
CodeVariableDeclarationStatement tempInput = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.Vector3)), tempInputName, new CodeObjectCreateExpression(typeof(EngineNS.Vector3), new CodeExpression[] { new CodePrimitiveExpression(0), new CodePrimitiveExpression(0), new CodePrimitiveExpression(0) }));
valueEvaluateMethod.Statements.Add(tempInput);
CodeExpression xValue = null;
CodeExpression yValue = null;
xValue = await Helper.GetEvaluateValueExpression(codeClass, valueEvaluateMethodContex, valueEvaluateMethod, mXLinkHandle, 0);
if (!Is1D)
{
yValue = await Helper.GetEvaluateValueExpression(codeClass, valueEvaluateMethodContex, valueEvaluateMethod, mYLinkHandle, 0);
}
CodeAssignStatement xValueAssign = new CodeAssignStatement();
xValueAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(tempInputName), "X");
xValueAssign.Right = xValue;
valueEvaluateMethod.Statements.Add(xValueAssign);
if (!Is1D)
{
CodeAssignStatement yValueAssign = new CodeAssignStatement();
yValueAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(tempInputName), "Y");
yValueAssign.Right = yValue;
valueEvaluateMethod.Statements.Add(yValueAssign);
}
valueEvaluateMethod.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(tempInputName)));
codeClass.Members.Add(valueEvaluateMethod);
Type bsType;
if (Is1D)
{
bsType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_BlendSpace1D);
}
else
{
bsType = typeof(EngineNS.Bricks.Animation.BlendTree.Node.BlendTree_BlendSpace2D);
}
var createLABSMethodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(bsType), "CreateSync"), new CodeExpression[] { new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(EngineNS.RName)), "GetRName", new CodeExpression[] { new CodePrimitiveExpression(FileName.Name) }) });
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(bsType, ValidName, createLABSMethodInvoke);
codeStatementCollection.Add(stateVarDeclaration);
var syncPlayPercentGropAssign = new CodeAssignStatement();
syncPlayPercentGropAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "SyncPlayPercentGrop");
syncPlayPercentGropAssign.Right = new CodePrimitiveExpression(SyncPlayPercentGrop);
codeStatementCollection.Add(syncPlayPercentGropAssign);
CodeAssignStatement inputFuncAssign = new CodeAssignStatement();
inputFuncAssign.Left = new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "EvaluateInput");
inputFuncAssign.Right = new CodeVariableReferenceExpression(valueEvaluateMethod.Name);
codeStatementCollection.Add(inputFuncAssign);
List <string> nofifies = new List <string>();
var info = await EditorCommon.Resources.ResourceInfoManager.Instance.CreateResourceInfoFromFile(FileName.Address + ".rinfo", null);
EngineNS.Bricks.Animation.AnimNode.BlendSpace bs = null;
if (Is1D)
{
bs = EngineNS.Bricks.Animation.AnimNode.BlendSpace1D.CreateSync(FileName);
}
else
{
bs = EngineNS.Bricks.Animation.AnimNode.BlendSpace2D.CreateSync(FileName);
}
if (info != null)
{
for (int j = 0; j < bs.Samples.Count; ++j)
{
var clip = bs.GetAnimationSample(j);
var refInfo = await EditorCommon.Resources.ResourceInfoManager.Instance.CreateResourceInfoFromFile(clip.AnimationName.Address + ".rinfo", null);
var animationInfo = refInfo as EditorCommon.ResourceInfos.AnimationClipResourceInfo;
nofifies.Clear();
foreach (var pair in animationInfo.NotifyTrackMap)
{
nofifies.Add(pair.NotifyName);
}
for (int i = 0; i < nofifies.Count; ++i)
{
var notify = nofifies[i];
var validNotifyName = StringRegex.GetValidName(notify);
validNotifyName = "Anim_Notify_" + validNotifyName;
if (hasTheNotifyMethod(codeClass, validNotifyName))
{
var attachNotifyEventExp = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression(ValidName), "BlendSpace"), "AttachNotifyEvent"), new CodeExpression[] { new CodePrimitiveExpression(j), new CodePrimitiveExpression(i), new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), validNotifyName) });
//CodeArrayIndexerExpression arrayIndex = new CodeArrayIndexerExpression(new CodeFieldReferenceExpression(animRef, "Notifies"), new CodePrimitiveExpression(i));
//CodeAttachEventStatement attachEvent = new CodeAttachEventStatement(arrayIndex, "OnNotify", new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), validNotifyName));
codeStatementCollection.Add(attachNotifyEventExp);
}
}
}
}
return;
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
if (!mCtrlValueLinkHandle.RecursionReached)
{
mCtrlValueLinkHandle.RecursionReached = true;
/*
* EngineNS.GamePlay.StateMachine.AnimationState State = new EngineNS.GamePlay.StateMachine.AnimationState("State", StateMachine);
* State.AnimationPose = StateMachine.AnimationPose;
*/
var stateMachineRef = context.AnimStateMachineReferenceExpression;
var validName = StringRegex.GetValidName(NodeName);
System.CodeDom.CodeVariableDeclarationStatement stateStateMent = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.Bricks.Animation.AnimStateMachine.LogicAnimationState)),
validName, new CodeObjectCreateExpression(new CodeTypeReference(typeof(EngineNS.Bricks.Animation.AnimStateMachine.LogicAnimationState)), new CodeExpression[] { new CodePrimitiveExpression(validName), stateMachineRef }));
codeStatementCollection.Add(stateStateMent);
stateRef = new CodeVariableReferenceExpression(validName);
CodeFieldReferenceExpression animPoseField = new CodeFieldReferenceExpression(stateRef, "AnimationPoseProxy");
CodeAssignStatement animPoseAssign = new CodeAssignStatement();
animPoseAssign.Left = animPoseField;
animPoseAssign.Right = context.StateMachineAnimPoseReferenceExpression;
codeStatementCollection.Add(animPoseAssign);
context.StateAnimPoseReferenceExpression = animPoseField;
//子图
context.AminStateReferenceExpression = stateRef;
if (mLinkedNodesContainer != null)
{
foreach (var ctrl in mLinkedNodesContainer.CtrlNodeList)
{
if ((ctrl is CodeDomNode.MethodOverride) ||
(ctrl is CodeDomNode.MethodCustom) || ctrl is FinalAnimPoseControl || ctrl is CodeDomNode.Animation.StateEntryControl)
{
await ctrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, element, context);
}
}
}
//指向的节点
for (int i = 0; i < mCtrlValueLinkHandle.GetLinkInfosCount(); ++i)
{
var linkInfo = mCtrlValueLinkHandle.GetLinkInfo(i);
if (linkInfo.m_linkFromObjectInfo == mCtrlValueLinkHandle)
{
//需要返回state，来添加两者之间 的转换关系
await linkInfo.m_linkToObjectInfo.HostNodeControl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, element, context);
if (mCtrlValueLinkHandle.LinkCurveType == enLinkCurveType.Line)
{
var linkCurve = linkInfo.LinkPath as CodeGenerateSystem.Base.ArrowLine;
foreach (var transitionCtrl in linkCurve.TransitionControlList)
{
//构建状态转换宏图
await transitionCtrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, element, context);
}
var desState = context.ReturnedAminStateReferenceExpression;
var stateTransitionMethod = context.StateTransitionMethodReferenceExpression;
if (stateTransitionMethod != null)
{
//生成转换代码
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(stateRef, "AddStateTransition");
var methodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(methodRef, new CodeExpression[] { desState, new CodeMethodReferenceExpression(null, stateTransitionMethod.Name) });
codeStatementCollection.Add(methodInvoke);
}
}
}
}
}
//将自己的state返回给上层递归
context.ReturnedAminStateReferenceExpression = stateRef;
//返回currentState
foreach (var node in mCtrlValueLinkHandle.GetLinkedObjects())
{
if (node is CodeDomNode.Animation.StateEntryControl)
{
context.FirstStateReferenceExpression = stateRef;
}
}
}
public override async System.Threading.Tasks.Task <CodeExpression> GCode_CodeDom_GenerateBehavior(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var linkObjs = mOutLinkHandle.GetLinkedObjects();
for (int i = 0; i < linkObjs.Length; ++i)
{
for (int j = i; j < linkObjs.Length; ++j)
{
if (linkObjs[i].GetLeftInCanvas(false) > linkObjs[j].GetLeftInCanvas(false))
{
var temp = linkObjs[i];
linkObjs[i] = linkObjs[j];
linkObjs[j] = temp;
}
}
}
List <CodeExpression> childrenNode = new List <CodeExpression>();
for (int i = 0; i < linkObjs.Length; ++i)
{
var linkElm = mOutLinkHandle.GetLinkedPinControl(i, true);
await linkObjs[i].GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, linkElm, context);
childrenNode.Add(linkObjs[i].GCode_CodeDom_GetSelfRefrence(null, null));
}
Type nodeType = null;
switch (CompositeNodeType)
{
case CompositeNodeType.Select:
{
nodeType = typeof(EngineNS.Bricks.AI.BehaviorTree.Composite.SelectBehavior);
}
break;
case CompositeNodeType.RandomSelect:
{
nodeType = typeof(EngineNS.Bricks.AI.BehaviorTree.Composite.SelectBehavior);
}
break;
case CompositeNodeType.Sequence:
{
nodeType = typeof(EngineNS.Bricks.AI.BehaviorTree.Composite.SequenceBehavior);
}
break;
case CompositeNodeType.Parallel:
{
nodeType = typeof(EngineNS.Bricks.AI.BehaviorTree.Composite.ParallelBehavior);
}
break;
}
CodeVariableDeclarationStatement stateVarDeclaration = new CodeVariableDeclarationStatement(nodeType, ValidName, new CodeObjectCreateExpression(new CodeTypeReference(nodeType)));
codeStatementCollection.Add(stateVarDeclaration);
for (int i = 0; i < linkObjs.Length; ++i)
{
var addChild = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(ValidName), "AddChild"), new CodeExpression[] { childrenNode[i] });
codeStatementCollection.Add(addChild);
}
return(new CodeVariableReferenceExpression(ValidName));
}
public void GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, CodeExpression expression, string strValueName)
{
GetGradientDatas();
if (GradientDatas.Count > 1)
{
for (int i = 1; i < GradientDatas.Count; i++)
{
var value = expression;
var offset1 = GradientDatas[i - 1].Offset;
var color1 = GradientDatas[i - 1].GradientColor;
var offset2 = GradientDatas[i].Offset;
var color2 = GradientDatas[i].GradientColor;
CodeObjectCreateExpression color1obj = new CodeObjectCreateExpression("EngineNS.Color4", new CodeExpression[] { });
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Alpha));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Red));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Green));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Blue));
CodeObjectCreateExpression color2obj = new CodeObjectCreateExpression("EngineNS.Color4", new CodeExpression[] { });
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Alpha));
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Red));
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Green));
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Blue));
//"t = (value - offset1) / (offset2 - offset1) "
CodeBinaryOperatorExpression v1 = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(offset2));
CodeBinaryOperatorExpression v2 = new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(offset1),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(offset2));
CodeBinaryOperatorExpression v3 = new CodeBinaryOperatorExpression(
v1,
CodeBinaryOperatorType.Divide,
v2);
var typeref = new System.CodeDom.CodeTypeReferenceExpression("EngineNS.Color4");
//Lerp( Color4 color1, Color4 color2, float amount )
var methodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(
// targetObject that contains the method to invoke.
typeref,
// methodName indicates the method to invoke.
"Lerp",
// parameters array contains the parameters for the method.
new CodeExpression[] { color2obj, color1obj, v3 });
CodeAssignStatement result = new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), methodInvoke);
// CodeBinaryOperatorExpression result = new CodeBinaryOperatorExpression(
//new CodeVariableReferenceExpression(strValueName),
// CodeBinaryOperatorType.Assign,
// methodInvoke);
var greaterthan = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression(offset2));
var lessthan = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(offset1));
if (i == GradientDatas.Count - 1)
{
var first = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(offset2));
codeStatementCollection.Add(new CodeConditionStatement(
first,
new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), color2obj)));
}
if (i == 1)
{
var last = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression(offset1));
codeStatementCollection.Add(new CodeConditionStatement(
last,
new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), color1obj)));
}
codeStatementCollection.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(greaterthan, CodeBinaryOperatorType.BooleanAnd, lessthan),
result));
}
}
else if (GradientDatas.Count == 1)
{
var color1 = GradientDatas[0].GradientColor;
CodeObjectCreateExpression color1obj = new CodeObjectCreateExpression("EngineNS.Color4", new CodeExpression[] { });
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Alpha));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Red));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Green));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Blue));
codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), color1obj));
}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
/*生成代码
* EngineNS.Graphics.Mesh.Animation.CGfxAnimationSequence batmanidle = new EngineNS.Graphics.Mesh.Animation.CGfxAnimationSequence();
* EngineNS.RName animName;
* animName = EngineNS.RName.GetRName("titandemo/character/batman/animation/[email protected]");
* batmanidle.Init(animName);
* batmanidle.AnimationPose = animPose;
* state.AddTickComponent(batmanidle);
* batmanidle.Notifies[0].OnNotify += this.Anim_Notify_Walk;
* return true;
*/
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
var validName = StringRegex.GetValidName(NodeName);
System.CodeDom.CodeVariableDeclarationStatement st = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.Bricks.Animation.AnimNode.AnimationClip)), validName, new CodeObjectCreateExpression(new CodeTypeReference(typeof(EngineNS.Bricks.Animation.AnimNode.AnimationClip))));
codeStatementCollection.Add(st);
var calcMethod = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeSnippetExpression("EngineNS.RName"), "GetRName", new CodePrimitiveExpression(RNameNodeName.Name));
CodeAssignStatement nodeNameAssign = new CodeAssignStatement();
CodeVariableDeclarationStatement rNameSt = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.RName)), "animName");
nodeNameAssign.Left = new CodeVariableReferenceExpression("animName");
nodeNameAssign.Right = calcMethod;
codeStatementCollection.Add(rNameSt);
codeStatementCollection.Add(nodeNameAssign);
CodeVariableReferenceExpression animRef = new CodeVariableReferenceExpression(validName);
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(animRef, "Init");
var methodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(methodRef, new CodeExpression[] { new CodeVariableReferenceExpression("animName") });
codeStatementCollection.Add(methodInvoke);
var animCP = CSParam as AnimationAssetConstructionParams;
CodeFieldReferenceExpression isLoopField = new CodeFieldReferenceExpression();
isLoopField.FieldName = "IsLoop";
isLoopField.TargetObject = animRef;
CodeAssignStatement isLoopAssign = new CodeAssignStatement();
isLoopAssign.Left = isLoopField;
isLoopAssign.Right = new CodePrimitiveExpression((bool)mTemplateClassInstance.GetType().GetProperty("IsLoop").GetValue(mTemplateClassInstance));
codeStatementCollection.Add(isLoopAssign);
CodeFieldReferenceExpression animPoseField = new CodeFieldReferenceExpression();
animPoseField.FieldName = "AnimationPoseProxy";
animPoseField.TargetObject = animRef;
CodeAssignStatement animPoseAssign = new CodeAssignStatement();
animPoseAssign.Left = animPoseField;
animPoseAssign.Right = context.AnimAssetAnimPoseProxyReferenceExpression;
codeStatementCollection.Add(animPoseAssign);
CodeMethodReferenceExpression addAnimTickComponentRef = new CodeMethodReferenceExpression(context.AnimAssetTickHostReferenceExpression, "AddTickComponent");
var addAnimTickComponentInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(addAnimTickComponentRef, new CodeExpression[] { animRef });
codeStatementCollection.Add(addAnimTickComponentInvoke);
var info = await EditorCommon.Resources.ResourceInfoManager.Instance.CreateResourceInfoFromFile(RNameNodeName.Address + ".rinfo", null);
var animationInfo = info as EditorCommon.ResourceInfos.AnimationClipResourceInfo;
animCP.Notifies.Clear();
foreach (var pair in animationInfo.NotifyTrackMap)
{
animCP.Notifies.Add(pair.NotifyName);
}
for (int i = 0; i < Notifies.Count; ++i)
{
var notify = Notifies[i];
var validNotifyName = StringRegex.GetValidName(notify);
validNotifyName = "Anim_Notify_" + validNotifyName;
if (hasTheNotifyMethod(codeClass, validNotifyName))
{
var attachNotifyEventExp = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeMethodReferenceExpression(animRef, "AttachNotifyEvent"), new CodeExpression[] { new CodePrimitiveExpression(i), new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), validNotifyName) });
//CodeArrayIndexerExpression arrayIndex = new CodeArrayIndexerExpression(new CodeFieldReferenceExpression(animRef, "Notifies"), new CodePrimitiveExpression(i));
//CodeAttachEventStatement attachEvent = new CodeAttachEventStatement(arrayIndex, "OnNotify", new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), validNotifyName));
codeStatementCollection.Add(attachNotifyEventExp);
}
}
}
