public override async Task GenerateMethods(IMacrossOperationContainer linkCtrl, CodeTypeDeclaration macrossClass, CodeGenerateSystem.Base.GenerateCodeContext_Class codeClassContext)
{
await base.GenerateMethods(linkCtrl, macrossClass, codeClassContext);
Category graphCategory;
CodeMemberMethod constructLAGraphMethod = null;
foreach (var member in macrossClass.Members)
{
if (member is CodeGenerateSystem.CodeDom.CodeMemberMethod)
{
var method = member as CodeGenerateSystem.CodeDom.CodeMemberMethod;
if (method.Name == "ConstructLAGraph")
{
constructLAGraphMethod = method;
}
}
}
if (constructLAGraphMethod == null)
{
constructLAGraphMethod = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
constructLAGraphMethod.Name = "ConstructLAGraph";
constructLAGraphMethod.Attributes = MemberAttributes.Override | MemberAttributes.Public;
macrossClass.Members.Add(constructLAGraphMethod);
}
if (linkCtrl.MacrossOpPanel.CategoryDic.TryGetValue(MacrossPanel.LogicAnimationGraphNodeCategoryName, out graphCategory))
{
for (int k = 0; k < graphCategory.Items.Count; ++k)
{
var linkNodes = graphCategory.Items[k].Children;
var lAStatesBridge = new LAStatesBridge();
lAStatesBridge.ConstructLAGraphMethod = constructLAGraphMethod;
await GenerateLAStateMachine(graphCategory.Items[k], linkCtrl, macrossClass, codeClassContext, lAStatesBridge);
for (int i = 0; i < linkNodes.Count; i++)
{
var graph = linkNodes[i];
await GenerateLAStates(graph, linkCtrl, macrossClass, codeClassContext, lAStatesBridge);
}
for (int i = 0; i < linkNodes.Count; i++)
{
var graph = linkNodes[i];
await GenerateLATransitions(graph, linkCtrl, macrossClass, codeClassContext, lAStatesBridge);
}
}
}
if (linkCtrl.MacrossOpPanel.CategoryDic.TryGetValue(MCLAMacrossPanel.LogicAnimationPostProcessCategoryName, out graphCategory))
{
for (int k = 0; k < graphCategory.Items.Count; ++k)
{
var linkNodes = graphCategory.Items[k].Children;
var lAStatesBridge = new LAStatesBridge();
lAStatesBridge.ConstructLAGraphMethod = constructLAGraphMethod;
await GenerateLAPostProcess(graphCategory.Items[k], linkCtrl, macrossClass, codeClassContext, lAStatesBridge);
}
}
}
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)
{
DataGradient.SetDataCollect();
var InitArray = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
InitArray.Name = "InitArray";
InitArray.ReturnType = new CodeTypeReference(typeof(void));
InitArray.Attributes = MemberAttributes.Public | MemberAttributes.Override;
codeClass.Members.Add(InitArray);
CodeStatementCollection initcollection = new CodeStatementCollection();
DataGradient.GCode_CodeDom_GenerateCode_For(codeClass, initcollection, "DataArray");
InitArray.Statements.AddRange(initcollection);
}
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);
await GenerateCachedPose(codeClass, initMethod.Statements, linkElm, methodContext);
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 returnExp = linkObj.GCode_CodeDom_GetSelfRefrence(mCtrlValueInputHandle, methodContext);
if (returnExp != null)
{
CodeFieldReferenceExpression animPoseField = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(returnExp, "AnimationPoseProxy"),"Pose");
CodeAssignStatement animPoseAssign = new CodeAssignStatement();
animPoseAssign.Left = animPoseField;
animPoseAssign.Right = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "AnimationPoseProxy"),"Pose");
initMethod.Statements.Add(animPoseAssign);
}
}
public async Task <CodeMemberMethod> GCode_CodeDom_GenerateTransitionLambdaMethod(CodeTypeDeclaration codeClass, LinkPinControl element, GenerateCodeContext_Method context)
{
var name = StringRegex.GetValidName("Transition" + HostNodesContainer.TitleString + EngineNS.Editor.Assist.GetValuedGUIDString(this.Id) + "_Lambda");
foreach (var member in codeClass.Members)
{
if (member is CodeGenerateSystem.CodeDom.CodeMemberMethod)
{
var existMethod = member as CodeGenerateSystem.CodeDom.CodeMemberMethod;
if (existMethod.Name == name)
{
return(existMethod);
}
}
}
CodeGenerateSystem.CodeDom.CodeMemberMethod method = new CodeGenerateSystem.CodeDom.CodeMemberMethod()
{
Name = name,
Attributes = MemberAttributes.Public | MemberAttributes.Final,
ReturnType = new CodeTypeReference(typeof(bool)),
};
codeClass.Members.Add(method);
if (!mCtrlValueInputHandle.HasLink)
{
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true)));
}
else
{
var linkObj = mCtrlValueInputHandle.GetLinkedObject(0, true);
var linkElm = mCtrlValueInputHandle.GetLinkedPinControl(0, true);
var methodContext = new GenerateCodeContext_Method(context.ClassContext, method);
if (!linkObj.IsOnlyReturnValue)
{
await linkObj.GCode_CodeDom_GenerateCode(codeClass, method.Statements, linkElm, methodContext);
}
var exp = linkObj.GCode_CodeDom_GetValue(mCtrlValueInputHandle.GetLinkedPinControl(0), methodContext);
method.Statements.Add(new CodeMethodReturnStatement(exp));
}
return(method);
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
DataGradient.SetDataCollect();
var InitArray = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
InitArray.Name = "InitArray";
InitArray.ReturnType = new CodeTypeReference(typeof(void));
InitArray.Attributes = MemberAttributes.Public | MemberAttributes.Override;
codeClass.Members.Add(InitArray);
var GetStartValue = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
GetStartValue.Name = "GetStartValue";
GetStartValue.ReturnType = new CodeTypeReference(typeof(void));
GetStartValue.Attributes = MemberAttributes.Public | MemberAttributes.Override;
codeClass.Members.Add(GetStartValue);
CodeStatementCollection initcollection = new CodeStatementCollection();
DataGradient.DataGradient1.GCode_CodeDom_GenerateCode_For(codeClass, initcollection, "DataArray");
DataGradient.DataGradient1.GCode_CodeDom_GenerateCode(codeClass, GetClassName(), GetStartValue, "", "StartValue");
//设置power
{
//InitArray = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
//InitArray.Name = "InitArray";
//InitArray.ReturnType = new CodeTypeReference(typeof(void));
//InitArray.Attributes = MemberAttributes.Public | MemberAttributes.Override;
//codeClass.Members.Add(InitArray);
//initcollection = new CodeStatementCollection();
DataGradient.DataGradient2.GCode_CodeDom_GenerateCode_For(codeClass, initcollection, "Power.DataArray");
DataGradient.DataGradient2.GCode_CodeDom_GenerateCode(codeClass, GetClassName(), GetStartValue, "Power", "Power.StartValue");
//InitArray.Statements.AddRange(initcollection);
}
InitArray.Statements.AddRange(initcollection);
}
public override async Task GenerateMethods(IMacrossOperationContainer linkCtrl, CodeTypeDeclaration macrossClass, CodeGenerateSystem.Base.GenerateCodeContext_Class codeClassContext)
{
await base.GenerateMethods(linkCtrl, macrossClass, codeClassContext);
Category graphCategory;
CodeGenerateSystem.CodeDom.CodeMemberMethod constructLAGraphMethod = null;
foreach (var member in macrossClass.Members)
{
if (member is CodeGenerateSystem.CodeDom.CodeMemberMethod)
{
var method = member as CodeGenerateSystem.CodeDom.CodeMemberMethod;
if (method.Name == "ConstructBTGraph")
{
constructLAGraphMethod = method;
}
}
}
if (constructLAGraphMethod == null)
{
constructLAGraphMethod = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
constructLAGraphMethod.Name = "ConstructBTGraph";
constructLAGraphMethod.Attributes = MemberAttributes.Override | MemberAttributes.Public;
macrossClass.Members.Add(constructLAGraphMethod);
}
if (linkCtrl.MacrossOpPanel.CategoryDic.TryGetValue(McBTMacrossPanel.BehaviorTreeCategoryName, out graphCategory))
{
for (int k = 0; k < graphCategory.Items.Count; ++k)
{
var linkNodes = graphCategory.Items[k].Children;
var btBridge = new BehaviorTreeBridge();
btBridge.ConstructBTGraphMethod = constructLAGraphMethod;
await GenerateBehaviorTree(graphCategory.Items[k], linkCtrl, macrossClass, codeClassContext, btBridge);
}
}
}
public async System.Threading.Tasks.Task GCode_CodeDom_GenerateMethodCode(CodeTypeDeclaration codeClass, LinkPinControl element, GenerateCodeContext_Class context, MethodGenerateData data)
{
var csParam = CSParam as MethodOverrideConstructParam;
Type[] paramTypes = new Type[csParam.MethodInfo.Params.Count];
for (int i = 0; i < paramTypes.Length; i++)
{
switch (csParam.MethodInfo.Params[i].FieldDirection)
{
case FieldDirection.In:
if (csParam.MethodInfo.Params[i].IsParamsArray)
{
throw new InvalidOperationException("未实现");
}
else
{
paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType;
}
break;
case FieldDirection.Out:
case FieldDirection.Ref:
if (csParam.MethodInfo.Params[i].IsParamsArray)
{
throw new InvalidOperationException("未实现");
}
else
{
paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType.MakeByRefType();
}
break;
}
}
EngineNS.Editor.MacrossMemberAttribute.enMacrossType macrossType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable;
if (csParam.MethodInfo.IsFromMacross)
{
macrossType |= EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable;
}
else
{
var methodInfo = csParam.MethodInfo.ParentClassType.GetMethod(csParam.MethodInfo.MethodName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static, null, paramTypes, null);
var atts = methodInfo.GetCustomAttributes(typeof(EngineNS.Editor.MacrossMemberAttribute), false);
if (atts.Length > 0)
{
var macrossMemberAtt = atts[0] as EngineNS.Editor.MacrossMemberAttribute;
macrossType = macrossMemberAtt.MacrossType;
}
}
if (element == null || element == mCtrlMethodPin_Next)
{
var methodCode = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
methodCode.Attributes = MemberAttributes.Override;
//if (mMethodInfo != null)
//{
if (csParam.MethodInfo.IsFamily)
{
methodCode.Attributes |= MemberAttributes.Family;
}
if (csParam.MethodInfo.IsFamilyAndAssembly)
{
methodCode.Attributes |= MemberAttributes.FamilyAndAssembly;
}
if (csParam.MethodInfo.IsFamilyOrAssembly)
{
methodCode.Attributes |= MemberAttributes.FamilyOrAssembly;
}
if (csParam.MethodInfo.IsPublic)
{
methodCode.Attributes |= MemberAttributes.Public;
}
//}
//else
// methodCode.Attributes |= MemberAttributes.Public;
methodCode.Name = NodeName;
var mcType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow;
if (csParam.MethodInfo.MC_Callable)
{
mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable;
}
if (csParam.MethodInfo.MC_Overrideable)
{
mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable;
}
if (mcType != EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow)
{
methodCode.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(EngineNS.Editor.MacrossMemberAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(mcType))));
}
if (data != null)
{
foreach (var localParam in data.LocalParams)
{
var defVal = CodeGenerateSystem.Program.GetDefaultValueFromType(localParam.ParamType);
var initExp = Program.GetValueCode(methodCode.Statements, localParam.ParamType, defVal);
methodCode.Statements.Add(new CodeVariableDeclarationStatement(localParam.ParamType, localParam.ParamName, initExp));
}
}
string paramPreStr = "temp___";
//bool needUnsafeFlag = false;
string catchParamName = "(";
foreach (var paramNode in mChildNodes)
{
var paramExp = new System.CodeDom.CodeParameterDeclarationExpression();
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
var pmParam = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
paramExp.Direction = pm.ParamFlag;
if (pmParam.ParamInfo.ParameterDisplayType != null)
{
paramExp.Name = paramPreStr + pmParam.ParamInfo.ParamName;
paramExp.Type = new CodeTypeReference(pmParam.ParamInfo.ParameterType);
}
else
{
paramExp.Name = pmParam.ParamInfo.ParamName;
paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType);
}
//if (pm.ParamType.IsPointer)
// needUnsafeFlag = true;
}
else if (paramNode is ParamParameterControl)
{
var pm = paramNode as ParamParameterControl;
paramExp.Name = pm.ParamName;
paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType);
//if (pm.ParamType.IsPointer)
// needUnsafeFlag = true;
}
else if (paramNode is MethodInvoke_DelegateControl)
{
var pm = paramNode as MethodInvoke_DelegateControl;
paramExp.Name = pm.ParamName;
paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType);
}
methodCode.Parameters.Add(paramExp);
catchParamName += paramExp.Type + " " + paramExp.Name + ",";
}
// 所有函数全部unsafe
//if (needUnsafeFlag)
{
//var typeName = MethodReturnType.FullName;
methodCode.ReturnType = new CodeTypeReference(MethodReturnType);
if (MethodReturnType == typeof(System.Threading.Tasks.Task) || MethodReturnType.BaseType == typeof(System.Threading.Tasks.Task))
{
methodCode.IsAsync = true;
}
else
{
if (EngineNS.Editor.MacrossMemberAttribute.HasType(macrossType, EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unsafe))
{
methodCode.IsUnsafe = true;
}
}
}
//else
// methodCode.ReturnType = new CodeTypeReference(MethodReturnType);
catchParamName = catchParamName.TrimEnd(',');
catchParamName += ")";
var tryCatchExp = new System.CodeDom.CodeTryCatchFinallyStatement();
tryCatchExp.TryStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "Begin", new CodeExpression[0]));
var exName = "ex_" + EngineNS.Editor.Assist.GetValuedGUIDString(Id);
var cah = new System.CodeDom.CodeCatchClause(exName);
cah.Statements.Add(new System.CodeDom.CodeExpressionStatement(
new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(
new System.CodeDom.CodeSnippetExpression("EngineNS.Profiler.Log"), "WriteException",
new System.CodeDom.CodeVariableReferenceExpression(exName),
new CodePrimitiveExpression("Macross异常"))));
tryCatchExp.CatchClauses.Add(cah);
tryCatchExp.FinallyStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "End", new CodeExpression[0]));
string paramComment = "";
// 设置out参数默认值
foreach (var param in csParam.MethodInfo.Params)
{
if (param.ParameterDisplayType != null)
{
if (param.FieldDirection == FieldDirection.Out)
{
methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName),
new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType))));
}
methodCode.Statements.Add(new CodeVariableDeclarationStatement(param.ParameterDisplayType, param.ParamName, new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterDisplayType, new CodeVariableReferenceExpression(paramPreStr + param.ParamName))));
}
else
{
if (param.FieldDirection == FieldDirection.Out)
{
methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(param.ParamName),
new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType))));
}
}
paramComment += param.FieldDirection + "," + param.ParameterType.FullName + "|";
}
paramComment = paramComment.TrimEnd('|');
methodCode.Statements.Add(tryCatchExp);
foreach (var param in csParam.MethodInfo.Params)
{
// ref或out，需要将displayType造成的临时变量再赋给原函数参数
if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null)
{
methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName))));
}
}
if (csParam.MethodInfo.ReturnType != typeof(void) && csParam.MethodInfo.ReturnType != typeof(System.Threading.Tasks.Task))
{
var retVal = CodeGenerateSystem.Program.GetDefaultValueFromType(csParam.MethodInfo.ReturnType);
methodCode.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(retVal)));
}
if (csParam.MethodInfo.IsFromMacross)
{
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {csParam.MethodInfo.FuncId.ToString()} {NodeName} {paramComment}"));
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998"));
codeClass.Members.Add(methodCode);
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998"));
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {csParam.MethodInfo.FuncId.ToString()} {NodeName}"));
}
else
{
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {NodeName} {paramComment}"));
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998"));
codeClass.Members.Add(methodCode);
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998"));
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {NodeName}"));
}
var methodContext = new CodeGenerateSystem.Base.GenerateCodeContext_Method(context, methodCode);
// 收集用于调试的数据的代码
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(tryCatchExp.TryStatements);
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var paramCtrl = paramNode as MethodInvokeParameterControl;
CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetTypeString(paramCtrl.ParamPin, methodContext), methodContext);
}
else if (paramNode is ParamParameterControl)
{
throw new InvalidOperationException();
}
}
// 断点
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
// 设置数据
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var paramCtrl = paramNode as MethodInvokeParameterControl;
CodeDomNode.BreakPoint.GetSetDataValueCodeStatement(breakCondStatement.TrueStatements, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetType(paramCtrl.ParamPin, methodContext));
}
else if (paramNode is ParamParameterControl)
{
throw new InvalidOperationException();
}
}
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(tryCatchExp.TryStatements, debugCodes);
if (mCtrlMethodPin_Next.HasLink)
{
methodContext.ReturnValueType = MethodReturnType;
await mCtrlMethodPin_Next.GetLinkedObject(0, false).GCode_CodeDom_GenerateCode(codeClass, tryCatchExp.TryStatements, mCtrlMethodPin_Next.GetLinkedPinControl(0, false), methodContext);
}
}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, LinkPinControl element, GenerateCodeContext_Method context)
{
var SetMaterialInstanceValue = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
SetMaterialInstanceValue.Name = "SetMaterialInstanceValue";
SetMaterialInstanceValue.ReturnType = new CodeTypeReference(typeof(void));
SetMaterialInstanceValue.Attributes = MemberAttributes.Public | MemberAttributes.Override;
codeClass.Members.Add(SetMaterialInstanceValue);
var param = new CodeParameterDeclarationExpression(typeof(EngineNS.Graphics.Mesh.CGfxMesh), "mesh");
SetMaterialInstanceValue.Parameters.Add(param);
SetMaterialInstanceValue.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "keyindex"));
SetMaterialInstanceValue.Statements.Add(new CodeVariableDeclarationStatement(typeof(string), "varname"));
var varmesh = new CodeVariableReferenceExpression("mesh");
for (int i = 0; i < ShowValues.Count; i++)
{
var showvalue = ShowValues[i];
foreach (var varvalue in showvalue.VarRNameValues)
{
var varmeshMtlInst = new CodeVariableReferenceExpression("mesh.MtlMeshArray[" + i + "].MtlInst");
SetMaterialInstanceValue.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("varname"), new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmeshMtlInst, "GetVarName", new CodeExpression[] { new CodePrimitiveExpression(varvalue.Key), new CodePrimitiveExpression(true) })));
SetMaterialInstanceValue.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("keyindex"), new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McFindVar", new CodeExpression[] { new CodePrimitiveExpression(i), new CodeVariableReferenceExpression("varname") })));
if (varvalue.Value.GetType().Equals(typeof(float)))
{
SetMaterialInstanceValue.Statements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McSetVarFloat", new CodeExpression[] { new CodePrimitiveExpression(i), new CodeVariableReferenceExpression("keyindex"), new CodePrimitiveExpression((float)varvalue.Value), new CodePrimitiveExpression(0) }));
}
else if (varvalue.Value.GetType().Equals(typeof(Vector2)))
{
Vector2 value = (Vector2)varvalue.Value;
SetMaterialInstanceValue.Statements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McSetVarVector2", new CodeExpression[] { new CodePrimitiveExpression(i), new CodeVariableReferenceExpression("keyindex"), new CodeObjectCreateExpression(typeof(Vector2), new CodeExpression[] { new CodePrimitiveExpression(value.X), new CodePrimitiveExpression(value.Y) }), new CodePrimitiveExpression(0) }));
}
else if (varvalue.Value.GetType().Equals(typeof(Vector3)))
{
Vector3 value = (Vector3)varvalue.Value;
SetMaterialInstanceValue.Statements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McSetVarVector3", new CodeExpression[] { new CodePrimitiveExpression(i), new CodeVariableReferenceExpression("keyindex"), new CodeObjectCreateExpression(typeof(Vector3), new CodeExpression[] { new CodePrimitiveExpression(value.X), new CodePrimitiveExpression(value.Y), new CodePrimitiveExpression(value.Z) }), new CodePrimitiveExpression(0) }));
}
else if (varvalue.Value.GetType().Equals(typeof(Vector4)))
{
Vector4 value = (Vector4)varvalue.Value;
SetMaterialInstanceValue.Statements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McSetVarColor4", new CodeExpression[] { new CodePrimitiveExpression(i), new CodeVariableReferenceExpression("keyindex"), new CodeObjectCreateExpression(typeof(Vector4), new CodeExpression[] { new CodePrimitiveExpression(value.X), new CodePrimitiveExpression(value.Y), new CodePrimitiveExpression(value.Z), new CodePrimitiveExpression(value.W) }), new CodePrimitiveExpression(0) }));
}
else if (varvalue.Value.GetType().Equals(typeof(EngineNS.Color)))
{
EngineNS.Color value = (EngineNS.Color)varvalue.Value;
SetMaterialInstanceValue.Statements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McSetVarColor4", new CodeExpression[] { new CodePrimitiveExpression(i), new CodeVariableReferenceExpression("keyindex"), new CodeObjectCreateExpression(typeof(Vector4), new CodeExpression[] { new CodePrimitiveExpression(value.R), new CodePrimitiveExpression(value.G), new CodePrimitiveExpression(value.B), new CodePrimitiveExpression(value.A) }), new CodePrimitiveExpression(0) }));
}
}
foreach (var srvvalue in showvalue.SRVRNameValues)
{
//var texture = CEngine.Instance.TextureManager.GetShaderRView(CEngine.Instance.RenderContext, value);
////elem.VarObject.SceneMesh.MtlMeshArray[elem.VarObject.MtlIndex].MtlInst.GetSRVName((uint)elem.VarObject.Index, true);
//elem.VarObject.SceneMesh.McSetTexture(elem.VarObject.MtlIndex, key, value);
//elem.VarObject.Host.AddSRVValue(elem.VarObject.Index, value);
SetMaterialInstanceValue.Statements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(varmesh, "McSetTexture", new CodeExpression[] { new CodePrimitiveExpression(i), new CodePrimitiveExpression(srvvalue.Key), new CodeSnippetExpression("EngineNS.CEngine.Instance.FileManager.GetRName(\"" + srvvalue.Value + "\")") }));
}
}
}
