protected override void LoadLink(XndNode xndNode)
{
mIsLoadingLinks = true;
mLinkPairs.Clear();
var att = xndNode.FindAttrib("TransitionLinks");
att.BeginRead();
switch (att.Version)
{
case 0:
{
int count = 0;
att.Read(out count);
for (int i = 0; i < count; i++)
{
var pair = new LinkPair();
att.Read(out pair.LoadedLinkFrom);
att.Read(out pair.LoadedLinkTo);
mLinkPairs.Add(pair);
}
}
break;
}
att.EndRead();
mIsLoadingLinks = false;
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
await base.Load(xndNode);
var att = xndNode.FindAttrib("DefaultParamValue");
if (att != null)
{
att.BeginRead();
switch (att.Version)
{
case 0:
{
att.ReadMetaObject(mTemplateClassInstance);
}
break;
case 1:
{
CodeGenerateSystem.Base.PropertyClassGenerator.LoadClassInstanceProperties(mTemplateClassInstance, att);
}
break;
}
att.EndRead();
}
var classType = mTemplateClassInstance.GetType();
var property = classType.GetProperty("Color");
EngineNS.Color color = (EngineNS.Color)property.GetValue(mTemplateClassInstance);
ColorBrush = new SolidColorBrush(Color.FromArgb(color.A, color.R, color.G, color.B));
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
await base.Load(xndNode);
var param = CSParam as MethodInvoke_DelegateControlConstructionParams;
for (int i = 0; i < mChildNodes.Count; i++)
{
var paramNode = mChildNodes[i] as MethodInvokeParameterControl;
if (paramNode == null)
{
continue;
}
// 将参数的配置指向同一个地址
var paramNodeParam = paramNode.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
paramNodeParam.ParamInfo = param.InputParmas[i];
paramNode.ParamPin.SetBinding(CodeGenerateSystem.Controls.LinkInControl.NameStringProperty, new Binding("UIDisplayParamName")
{
Source = paramNodeParam.ParamInfo
});
}
OnLoad_WPF();
}
//EngineNS.Thread.Async.TaskLoader.WaitContext WaitContext = new EngineNS.Thread.Async.TaskLoader.WaitContext();
//async System.Threading.Tasks.Task<EngineNS.Thread.Async.TaskLoader.WaitContext> AwaitLoad()
//{
// return await EngineNS.Thread.Async.TaskLoader.Awaitload(WaitContext);
//}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
//await AwaitLoad();
NeedResetLoadValue = await ParticleDataSaveLoad.LoadData("ParticleTextureCutNode", xndNode, CSParam as ParticleTextureCutControlConstructionParams, this, mLinkedNodesContainer);
await base.Load(xndNode);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
await base.Load(xndNode);
var att = xndNode.FindAttrib("DefaultParamValue");
if (att != null)
{
att.BeginRead();
switch (att.Version)
{
case 0:
{
int count = 0;
att.Read(out count);
for (int i = 0; i < count; i++)
{
GradientData obj = new GradientData();;
att.ReadMetaObject(obj);
GradientDatas.Add(obj);
}
SetGradientDatas(GradientDatas);
}
break;
}
att.EndRead();
}
}
public override void Save(XndNode xndNode, bool newGuid)
{
ParticleDataSaveLoad.SaveData("ParticleMaterialInstanceNode", xndNode, newGuid, CSParam as ParticleMaterialInstanceControlConstructionParams, this, mLinkedNodesContainer);
base.Save(xndNode, newGuid);
if (ShowValues.Count > 0)
{
InitValueDatas = ShowValues;
}
var attr = xndNode.AddAttrib("MaterialInstance_control");
attr.Version = 0;
attr.BeginWrite();
attr.Write(InitValueDatas.Count);
for (int i = 0; i < InitValueDatas.Count; i++)
{
var showvalue = InitValueDatas[i];
attr.Write(showvalue.MaterialInstanceName);
attr.Write(showvalue.VarRNameValues.Count);
foreach (var varvalue in showvalue.VarRNameValues)
{
attr.Write(varvalue.Key);
attr.Write(varvalue.Value.GetType().FullName);
{
if (varvalue.Value.GetType().Equals(typeof(float)))
{
attr.Write((float)varvalue.Value);
//elem.VarObject.mMaterialInstance.SetVarValue(elem.VarObject.Index, 0, ref value);
}
else if (varvalue.Value.GetType().Equals(typeof(Vector2)))
{
attr.Write((Vector2)varvalue.Value);
}
else if (varvalue.Value.GetType().Equals(typeof(Vector3)))
{
attr.Write((Vector3)varvalue.Value);
}
else if (varvalue.Value.GetType().Equals(typeof(Vector4)))
{
attr.Write((Vector4)varvalue.Value);
}
else if (varvalue.Value.GetType().Equals(typeof(EngineNS.Color)))
{
attr.Write((Color4)varvalue.Value);
}
}
}
attr.Write(showvalue.SRVRNameValues.Count);
foreach (var srvvalue in showvalue.SRVRNameValues)
{
attr.Write(srvvalue.Key);
attr.Write(srvvalue.Value as RName);
}
}
attr.EndWrite();
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
try
{
await base.Load(xndNode);
var att = xndNode.FindAttrib("defaultParam");
if (att != null)
{
att.BeginRead();
switch (att.Version)
{
case 0:
{
att.ReadMetaObject(mTemplateClassInstance_All);
var allType = mTemplateClassInstance_All.GetType();
foreach (var pro in mTemplateClassInstance_Show.GetType().GetProperties())
{
var allPro = allType.GetProperty(pro.Name);
pro.SetValue(mTemplateClassInstance_Show, allPro.GetValue(mTemplateClassInstance_All));
}
}
break;
case 1:
{
CodeGenerateSystem.Base.PropertyClassGenerator.LoadClassInstanceProperties(mTemplateClassInstance_All, att);
var allType = mTemplateClassInstance_All.GetType();
foreach (var pro in mTemplateClassInstance_Show.GetType().GetProperties())
{
var allPro = allType.GetProperty(pro.Name);
pro.SetValue(mTemplateClassInstance_Show, allPro.GetValue(mTemplateClassInstance_All));
}
}
break;
}
att.EndRead();
}
foreach (var child in mChildNodes)
{
var childParam = child.CSParam as ExpandNodeChild.ExpandNodeChildConstructionParams;
foreach (var cb in StackPanel_Members.Children)
{
var cbTemp = cb as CheckBox;
if (((string)cbTemp.Content) == childParam.ParamName)
{
cbTemp.Tag = child;
}
}
}
}
catch (System.Exception e)
{
HasError = true;
ErrorDescription = "节点读取失败！";
System.Diagnostics.Debug.WriteLine($"节点读取失败！：Name=展开 {NodeName}\r\n{e.ToString()}");
}
}
public override void Save(XndNode xndNode, bool newGuid)
{
var csParam = CSParam as ParticleColorControlConstructionParams;
csParam.Colume = _SaveData.Colume;
base.Save(xndNode, newGuid);
ColorGradient.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("MtlMacros");
att.BeginWrite();
att.WriteMetaObject(mMtlMacros);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
//ParticleDataSaveLoad.SaveData("ParticleRotationNode", xndNode, newGuid, CSParam as ParticleRotationControlConstructionParams, this);
var csParam = CSParam as ParticleRotationControlConstructionParams;
base.Save(xndNode, newGuid);
DataGradient.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
ParticleDataSaveLoad.SaveData("ParticleAcceleratedNode", xndNode, newGuid, CSParam as ParticleAcceleratedControlConstructionParams, this, mLinkedNodesContainer);
var csParam = CSParam as ParticleAcceleratedControlConstructionParams;
base.Save(xndNode, newGuid);
DataGradient.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("loopData");
att.BeginWrite();
att.Write(CountDefaultValue);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
await base.Load(xndNode);
var att = xndNode.FindAttrib("loopData");
att.BeginRead();
att.Read(out mCountDefaultValue);
att.EndRead();
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("DefaultParamValue");
att.Version = 1;
att.BeginWrite();
CodeGenerateSystem.Base.PropertyClassGenerator.SaveClassInstanceProperties(mTemplateClassInstance, att);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("_shaderVar");
att.Version = 0;
att.BeginWrite();
att.WriteMetaObject(ShaderVarInfo);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("Data");
att.Version = 0;
att.BeginWrite();
att.Write(TargetTypeName);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public static void SaveData(string name, XndNode xndNode, bool newGuid, StructNodeControlConstructionParams csparam, IParticleNode pnode, CodeGenerateSystem.Controls.NodesContainerControl mLinkedNodesContainer)
{
var psd = pnode as IParticleSaveData;
if (psd != null && psd.IsLoadLink() == false)
{
var test = ParticleDataSaveLoad.LoadData(csparam, mLinkedNodesContainer, psd);
}
if (mLinkedNodesContainer != null)
{
var att = xndNode.AddAttrib(name);
att.Version = 0;
att.BeginWrite();
List <string> keys = new List <string>();
//var csparam = CSParam as StructNodeControlConstructionParams;
if (csparam.CategoryDic == null)
{
att.Write(0);
att.EndWrite();
}
else
{
att.Write(csparam.CategoryDic.Count);
foreach (var category in csparam.CategoryDic)
{
att.Write(category.Key);
att.Write(category.Value.Items.Count);
keys.Add(category.Key);
}
att.EndWrite();
for (int i = 0; i < keys.Count; i++)
{
var Node = xndNode.AddNode(keys[i], 0, 0);
var category = csparam.CategoryDic[keys[i]];
for (int j = 0; j < category.Items.Count; j++)
{
var childNode = Node.AddNode("childNode", 0, 0);
category.Items[j].Save(childNode);
}
}
}
}
//base.Save(xndNode, newGuid);
if (pnode.GetCreateObject() != null)
{
var childenode = xndNode.AddNode("CreateObjectNode", 0, 0);
pnode.GetCreateObject().Save(childenode, newGuid);
}
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
var att = xndNode.FindAttrib("Data");
if (att != null)
{
att.BeginRead();
switch (att.Version)
{
case 0:
{
att.ReadMetaObject(mTemplateClassInstance);
Int32 count;
att.Read(out count);
for (int i = 0; i < count; i++)
{
var bPt = att.ReadMetaObject() as EngineNS.BezierPointBase;
var pt = new EditorCommon.Controls.LineXBezierControl.BezierPoint(LineXBezierCtrl);
pt.Position = bPt.Position;
pt.ControlPoint = bPt.ControlPoint;
mBezierPoints.Add(pt);
}
att.Read(out mBezierWidth);
att.Read(out mBezierHeight);
}
break;
case 1:
{
CodeGenerateSystem.Base.PropertyClassGenerator.LoadClassInstanceProperties(mTemplateClassInstance, att);
Int32 count;
att.Read(out count);
for (int i = 0; i < count; i++)
{
var bPt = att.ReadMetaObject() as EngineNS.BezierPointBase;
var pt = new EditorCommon.Controls.LineXBezierControl.BezierPoint(LineXBezierCtrl);
pt.Position = bPt.Position;
pt.ControlPoint = bPt.ControlPoint;
mBezierPoints.Add(pt);
}
att.Read(out mBezierWidth);
att.Read(out mBezierHeight);
}
break;
}
att.EndRead();
}
await base.Load(xndNode);
SetBezierPointsToCtrl();
foreach (var pt in mBezierPoints)
{
((EditorCommon.Controls.LineXBezierControl.BezierPoint)pt).CalculateOpposite();
}
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
//if (NeedInitGrapth)
//{
// var test = InitGraph();
//}
await base.Load(xndNode);
NeedResetLoadValue = await ParticleDataSaveLoad.LoadData2("ParticleSystemNode", xndNode, CSParam as ParticleSystemControlConstructionParams, this, mLinkedNodesContainer);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
try
{
await base.Load(xndNode);
var att = xndNode.FindAttrib("defaultParam");
if (att != null)
{
att.BeginRead();
switch (att.Version)
{
case 0:
{
Byte result;
att.Read(out result);
if (result == 1)
{
att.ReadMetaObject(mTemplateClassInstance);
}
}
break;
case 1:
{
Byte result;
att.Read(out result);
if (result == 1)
{
CodeGenerateSystem.Base.PropertyClassGenerator.LoadClassInstanceProperties(mTemplateClassInstance, att);
}
}
break;
}
att.EndRead();
}
foreach (var child in mChildNodes)
{
var childParameterCtrl = child as MethodInvokeParameterControl;
if (childParameterCtrl != null)
{
childParameterCtrl.OnUpdateParamTypeAction = OnUpdateChildParamType;
}
}
}
catch (System.Exception e)
{
HasError = true;
ErrorDescription = e.ToString();
}
InitTemplateClass_WPF(null);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
var att = xndNode.FindAttrib("MtlMacros");
if (att != null)
{
att.BeginRead();
att.ReadMetaObject(mMtlMacros);
att.EndRead();
this.IsDirty = false;
}
await base.Load(xndNode);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
//if (NeedInitGrapth)
//{
// var test = InitGraph();
//}
//await AwaitLoad();
await ParticleDataSaveLoad.LoadData2("ParticleAcceleratedNode", xndNode, CSParam as ParticleAcceleratedControlConstructionParams, this, mLinkedNodesContainer);
await base.Load(xndNode);
await DataGradient.Load(xndNode);
}
public override void Save(XndNode xndNode, bool newGuid)
{
GetGradientDatas();
var att = xndNode.AddAttrib("DefaultParamValue");
att.Version = 0;
att.BeginWrite();
att.Write(GradientDatas.Count);
for (int i = 0; i < GradientDatas.Count; i++)
{
att.WriteMetaObject(GradientDatas[i]);
}
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
//if (NeedInitGrapth)
//{
// var test = InitGraph();
//}
await base.Load(xndNode);
await ColorGradient.Load(xndNode);
var csParam = CSParam as ParticleColorControlConstructionParams;
_SaveData.Colume = csParam.Colume;
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("defaultParam");
att.Version = 1;
att.BeginWrite();
if (mTemplateClassInstance != null)
{
att.Write((Byte)1);
CodeGenerateSystem.Base.PropertyClassGenerator.SaveClassInstanceProperties(mTemplateClassInstance, att);
}
else
{
att.Write((Byte)0);
}
att.EndWrite(); base.Save(xndNode, newGuid);
}
public override void Save(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("defaultParam");
att.Version = 1;
att.BeginWrite();
var allType = mTemplateClassInstance_All.GetType();
foreach (var pro in mTemplateClassInstance_Show.GetType().GetProperties())
{
var allPro = allType.GetProperty(pro.Name);
allPro.SetValue(mTemplateClassInstance_All, pro.GetValue(mTemplateClassInstance_Show));
}
CodeGenerateSystem.Base.PropertyClassGenerator.SaveClassInstanceProperties(mTemplateClassInstance_All, att);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
var att = xndNode.FindAttrib("_shaderVar");
if (att != null)
{
switch (att.Version)
{
case 0:
{
att.BeginRead();
att.ReadMetaObject(ShaderVarInfo);
att.EndRead();
}
break;
}
}
await base.Load(xndNode);
}
public override void Save(XndNode xndNode, bool newGuid)
{
GetBezierPointsFromCtrl();
var att = xndNode.AddAttrib("Data");
att.Version = 1;
att.BeginWrite();
CodeGenerateSystem.Base.PropertyClassGenerator.SaveClassInstanceProperties(mTemplateClassInstance, att);
att.Write((Int32)mBezierPoints.Count);
foreach (var bPt in mBezierPoints)
{
var pt = new EngineNS.BezierPointBase(bPt.Position, bPt.ControlPoint);
att.WriteMetaObject(pt);
}
att.Write(mBezierWidth);
att.Write(mBezierHeight);
att.EndWrite();
base.Save(xndNode, newGuid);
}
public override async System.Threading.Tasks.Task Load(XndNode xndNode)
{
await base.Load(xndNode);
var att = xndNode.FindAttrib("Data");
if (att != null)
{
att.BeginRead();
switch (att.Version)
{
case 0:
{
att.Read(out mTargetTypeName);
}
break;
}
att.EndRead();
}
}
protected override void SaveLinks(XndNode xndNode, bool newGuid)
{
var att = xndNode.AddAttrib("TransitionLinks");
att.Version = 0;
att.BeginWrite();
att.Write((int)(LinkInfos.Count));
foreach (var link in LinkInfos)
{
// 创建新的GUID则输出以前的GUID
if (newGuid)
{
att.Write(link.m_linkFromObjectInfo.m_copyedGuid);
att.Write(link.m_linkToObjectInfo.m_copyedGuid);
}
else
{
att.Write(link.m_linkFromObjectInfo.GUID);
att.Write(link.m_linkToObjectInfo.GUID);
}
}
att.EndWrite();
}
