public void SaveXnd(IO.XndNode node, List <CombineVoxel.BoxVolume> bvs)
{
var set = new GamePlay.SceneGraph.GPvsSet();
set.WorldMatrix = this.WorldMatrix;
set.WorldMatrixInv = Matrix.Invert(ref this.WorldMatrix);
set.PvsData = mBitSets;
set.PvsCells = new List <GamePlay.SceneGraph.GPvsCell>(bvs.Count);
for (int i = 0; i < bvs.Count; i++)
{
var cellSize = bvs[i].Voxels[0].Shape.GetSize();
var cell = new GamePlay.SceneGraph.GPvsCell();
cell.BoundVolume.Minimum.X = cellSize.X * (float)bvs[i].xMin;
cell.BoundVolume.Minimum.Y = cellSize.Y * (float)bvs[i].yMin;
cell.BoundVolume.Minimum.Z = cellSize.Z * (float)bvs[i].zMin;
cell.BoundVolume.Maximum.X = cellSize.X * (float)bvs[i].xMax;
cell.BoundVolume.Maximum.Y = cellSize.Y * (float)bvs[i].yMax;
cell.BoundVolume.Maximum.Z = cellSize.Z * (float)bvs[i].zMax;
cell.PvsIndex = FindBitSetIndex(bvs[i].Voxels[0].Bits);
System.Diagnostics.Debug.Assert(cell.PvsIndex >= 0);
set.PvsCells.Add(cell);
}
var att = node.AddAttrib("BoxVolumes");
att.BeginWrite();
att.WriteMetaObject(set);
att.EndWrite();
}
public void SaveClusteredMesh(RName name)
{
var xnd = IO.XndHolder.NewXNDHolder();
IO.XndNode node = xnd.Node;
var attr = node.AddAttrib("Vertices");
attr.BeginWrite();
attr.Write(MeshVertices.Count);
for (int i = 0; i < MeshVertices.Count; i++)
{
attr.Write(MeshVertices[i]);
}
attr.EndWrite();
attr = node.AddAttrib("ClusterDatas");
attr.BeginWrite();
attr.Write(ClusterDatas.Count);
for (int i = 0; i < ClusterDatas.Count; i++)
{
attr.Write(ClusterDatas[i]);
}
attr.EndWrite();
attr = node.AddAttrib("IndexBuffer");
attr.BeginWrite();
attr.Write(IndexBuffer.Count);
for (int i = 0; i < IndexBuffer.Count; i++)
{
attr.Write(IndexBuffer[i]);
}
attr.EndWrite();
IO.XndHolder.SaveXND(name.Address, xnd);
}
public async System.Threading.Tasks.Task <bool> LoadXnd(IO.XndNode node)
{
return(await CEngine.Instance.EventPoster.Post(() =>
{
unsafe
{
var attr = node.FindAttrib("Desc");
if (attr != null)
{
attr.BeginRead();
string name;
attr.Read(out name);
this.MeshSource = RName.GetRName(name);
attr.EndRead();
}
attr = node.FindAttrib("Position");
if (attr == null)
{
return false;
}
attr.BeginRead();
int length;
attr.Read(out length);
if (length == 0)
{
return false;
}
Positions = new Vector3[length];
fixed(Vector3 *p = &Positions[0])
{
attr.Read((IntPtr)p, sizeof(Vector3) * Positions.Length);
}
attr.EndRead();
attr = node.FindAttrib("Data");
if (attr == null)
{
return false;
}
attr.BeginRead();
attr.Read(out length);
if (length == 0)
{
return false;
}
Datas = new Vector4[length];
fixed(Vector4 *p = &Datas[0])
{
attr.Read((IntPtr)p, sizeof(Vector4) * Datas.Length);
}
attr.EndRead();
}
return true;
}, Thread.Async.EAsyncTarget.AsyncIO));
}
public virtual async System.Threading.Tasks.Task <bool> LoadXndAsync(IO.XndNode node)
{
var ret = await CEngine.Instance.EventPoster.Post(() =>
{
return(SDK_GfxModifier_LoadXnd(CoreObject, node.CoreObject));
});
return(ret);
}
public override void Save2Xnd(IO.XndNode node)
{
if (Initializer != null)
{
var attr = node.AddAttrib("Initializer");
attr.BeginWrite();
attr.WriteMetaObject(Initializer);
attr.EndWrite();
}
}
public override void Save2Xnd(IO.XndNode node)
{
base.Save2Xnd(node);
//var packs = node.AddNode("PackActors", 0, 0);
//foreach(var i in Children)
//{
// var typeStr = Rtti.RttiHelper.GetTypeSaveString(i.GetType());
// var an = packs.AddNode(typeStr, 0, 0);
// i.Save2Xnd(an);
//}
}
public override void Save2Xnd(IO.XndNode node)
{
base.Save2Xnd(node);
var cpNodes = node.AddNode("CompChildren", 0, 0);
for (int i = 0; i < Components.Count; ++i)
{
var typeName = Rtti.RttiHelper.GetTypeSaveString(Components[i].GetType());
var cnode = cpNodes.AddNode(typeName, 0, 0);
Components[i].Save2Xnd(cnode);
}
}
public static GamePlay.SceneGraph.GPvsSet LoadXnd(IO.XndNode node)
{
var att = node.FindAttrib("BoxVolumes");
att.BeginRead();
var retVal = new GamePlay.SceneGraph.GPvsSet();
att.ReadMetaObject(retVal);
att.EndRead();
return(retVal);
}
public void Save2Xnd(IO.XndNode node)
{
var attr = node.AddAttrib("Properties");
attr.BeginWrite();
attr.Write(RttiHelper.GetTypeSaveString(MetaType));
attr.Write(MetaHash);
attr.Write(Members.Count);
foreach (var i in Members)
{
attr.Write(RttiHelper.GetTypeSaveString(i.PropInfo.MemberType));
attr.Write(i.Name);
}
attr.EndWrite();
}
public void Save2Xnd(IO.XndNode node)
{
unsafe
{
var attr = node.AddAttrib("Desc");
attr.BeginWrite();
if (MeshSource != null)
{
attr.Write(MeshSource.Name);
}
else
{
attr.Write("");
}
attr.EndWrite();
attr = node.AddAttrib("Position");
attr.BeginWrite();
attr.Write(Positions.Length);
fixed(Vector3 *p = &Positions[0])
{
attr.Write((IntPtr)p, sizeof(Vector3) * Positions.Length);
}
attr.EndWrite();
attr = node.AddAttrib("Data");
attr.BeginWrite();
attr.Write(Datas.Length);
fixed(Vector4 *p = &Datas[0])
{
attr.Write((IntPtr)p, sizeof(Vector4) * Datas.Length);
}
attr.EndWrite();
}
}
public void Save2Xnd(IO.XndNode node)
{
SDK_RcNavMesh_Save2Xnd(CoreObject, node.CoreObject);
}
public bool LoadXnd(IO.XndNode node)
{
return(SDK_RcNavMesh_LoadXnd(CoreObject, node.CoreObject));
}
public virtual bool LoadXnd(IO.XndNode node)
{
return((bool)SDK_GfxModifier_LoadXnd(CoreObject, node.CoreObject));
}
public bool RefreshResource(CRenderContext rc, string name, IO.XndNode node)
{
return(SDK_GfxMeshPrimitives_RefreshResource(CoreObject, rc.CoreObject, name, node.CoreObject));
}
private bool LoadXnd(IO.XndNode node, out bool isRedirection, out bool needSave)
{
needSave = false;
isRedirection = false;
var attr = node.FindAttrib("Properties");
if (attr == null)
{
return(false);
}
try
{
attr.BeginRead();
string metaStr;
attr.Read(out metaStr);
MetaType = RttiHelper.GetTypeFromSaveString(metaStr, out isRedirection);
if (MetaType == null)
{
return(false);
}
var method = MetaType.GetMethod("WhenMetaDataBeginLoad");
if (method != null && method.IsStatic)
{
method.Invoke(null, null);
}
UInt32 hash;
attr.Read(out hash);
MetaHash = hash;
Members.Clear();
int count = 0;
attr.Read(out count);
bool hasRedirectionType = false;
for (int i = 0; i < count; i++)
{
var item = new FieldDesc();
string typeStr;
attr.Read(out typeStr);
attr.Read(out item.Name);
var saveType = RttiHelper.GetTypeFromSaveString(typeStr, out hasRedirectionType);
if (hasRedirectionType)
{//如果有成员变量被重定向成别的类型，需要用到的metadata存盘成新的定向后的数据
needSave = true;
}
isRedirection = isRedirection || hasRedirectionType;
if (saveType == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "MetaData", $"RttiHelper.GetTypeFromSaveString == null: {typeStr}");
}
var pinfo = MetaType.GetProperty(item.Name);
if (pinfo != null)
{
if (saveType == pinfo.PropertyType)
{
item.PropInfo = new Rtti.PropMemberDesc(pinfo);
}
else
{
Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "MetaData", $"MetaData Property {item.Name} SaveType({typeStr}) != Type({pinfo.PropertyType.ToString()})");
item.PropInfo = new Rtti.LostedMemberDesc(saveType, MetaType, item.Name);
}
}
var finfo = MetaType.GetField(item.Name);
if (finfo != null)
{
if (saveType == finfo.FieldType)
{
System.Diagnostics.Debug.Assert(item.PropInfo == null);
item.PropInfo = new Rtti.FieldMemberDesc(finfo);
}
else
{
Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "MetaData", $"MetaData Field {item.Name} SaveType({typeStr}) != Type({finfo.FieldType.ToString()})");
//item.PropInfo = new Rtti.FieldMemberDesc(finfo);
item.PropInfo = new Rtti.LostedMemberDesc(saveType, MetaType, item.Name);
}
}
IO.Serializer.CustomSerializer custSerializer = null;
if (item.PropInfo == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "MetaData", $"MetaData can't find PropInfo: {item.Name}");
item.PropInfo = new Rtti.LostedMemberDesc(saveType, MetaType, item.Name);
}
else
{
var attrs = item.PropInfo.GetCustomAttributes(typeof(IO.Serializer.CustomFieldSerializerAttribute), true);
if (attrs != null && attrs.Length != 0)
{
var fsdesc = attrs[0] as IO.Serializer.CustomFieldSerializerAttribute;
if (fsdesc != null && fsdesc.SerializerType != null)
{
custSerializer = System.Activator.CreateInstance(fsdesc.SerializerType) as IO.Serializer.CustomSerializer;
}
}
}
if (custSerializer != null)
{
item.Serializer = custSerializer;
item.IsList = false;
}
else if (saveType != null)
{
item.Serializer = IO.Serializer.TypeDescGenerator.Instance.GetSerializer(saveType);
if (saveType.IsGenericType && (saveType.GetInterface(typeof(System.Collections.IList).FullName) != null))
{
var argType = saveType.GenericTypeArguments[0];
item.Serializer = IO.Serializer.TypeDescGenerator.Instance.GetSerializer(argType);
item.IsList = true;
}
else
{
item.IsList = false;
}
}
if (item.Serializer == null)
{
throw new TypeInitializationException(typeStr, null);
}
Members.Add(item);
}
}
finally
{
attr.EndRead();
}
return(true);
}
public virtual void Save2Xnd(IO.XndNode node)
{
SDK_GfxModifier_Save2Xnd(CoreObject, node.CoreObject);
}
public bool LoadClusteredMesh(RName name)
{
Name = name;
Cleanup();
var xnd = IO.XndHolder.SyncLoadXND(name.Address);
IO.XndNode node = xnd.Node;
var attr = node.FindAttrib("Vertices");
if (attr == null)
{
return(false);
}
attr.BeginRead();
int count = 0;
attr.Read(out count);
for (int i = 0; i < count; i++)
{
GpuSceneVertex vert;
attr.Read(out vert);
MeshVertices.Add(vert);
}
attr.EndRead();
attr = node.FindAttrib("ClusterDatas");
if (attr == null)
{
return(false);
}
attr.BeginRead();
attr.Read(out count);
for (int i = 0; i < count; i++)
{
GpuCluster cluster;
attr.Read(out cluster);
ClusterDatas.Add(cluster);
}
attr.EndRead();
attr = node.FindAttrib("IndexBuffer");
attr.BeginRead();
attr.Read(out count);
for (int i = 0; i < count; i++)
{
uint index;
attr.Read(out index);
IndexBuffer.Add(index);
}
attr.EndRead();
unsafe
{
ResourceState.ResourceSize = (uint)(MeshVertices.Count * sizeof(GpuSceneVertex) + ClusterDatas.Count * sizeof(GpuCluster) + IndexBuffer.Count * sizeof(uint));
}
return(true);
}
public override async System.Threading.Tasks.Task <bool> LoadXnd(CRenderContext rc, IO.XndNode node)
{
if (false == await base.LoadXnd(rc, node))
{
return(false);
}
//兼容老的版本..
if (Children.Count == 0)
{
var packs = node.FindNode("PackActors");
if (packs != null)
{
var nodes = packs.GetNodes();
foreach (var i in nodes)
{
var type = Rtti.RttiHelper.GetTypeFromSaveString(i.GetName());
if (type == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "Actor", $"Actor Type{i.GetName()} is invalid");
continue;
}
var act = System.Activator.CreateInstance(type) as Actor.GActor;
if (act == null)
{
continue;
}
if (false == await act.LoadXnd(rc, i))
{
Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "Actor", $"Actor Type{i.GetName()} LoadXnd failed");
continue;
}
act.SetParent(this);
}
}
}
EngineNS.Thread.Async.TaskLoader.Release(ref WaitContext, this);
return(true);
}
